diff --git a/.eslintrc b/.eslintrc
index 3bb95571e21..a6e8618d110 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -26,6 +26,8 @@
     // Code style
     "indent": [2, 2],
     "quotes": [2, "single"],
+    "semi": ["error", "always"],
+    "space-before-function-paren": ["error", "always"],
     "no-use-before-define": 0,
     "eqeqeq": [2, "smart"],
     "dot-notation": [2, {"allowKeywords": true, "allowPattern": ""}],
diff --git a/migrations/1_initial_migration.js b/migrations/1_initial_migration.js
index 42968952f7e..a4725fe7163 100644
--- a/migrations/1_initial_migration.js
+++ b/migrations/1_initial_migration.js
@@ -1,5 +1,5 @@
-var Migrations = artifacts.require('./Migrations.sol')
+var Migrations = artifacts.require('./Migrations.sol');
 
 module.exports = function (deployer) {
-  deployer.deploy(Migrations)
-}
+  deployer.deploy(Migrations);
+};
diff --git a/migrations/2_deploy_contracts.js b/migrations/2_deploy_contracts.js
index 5b396cb2de7..19ce1ca5c9b 100644
--- a/migrations/2_deploy_contracts.js
+++ b/migrations/2_deploy_contracts.js
@@ -6,4 +6,4 @@
 
 module.exports = function (deployer) {
   // deployer.deploy(Ownable);
-}
+};
diff --git a/package-lock.json b/package-lock.json
index 8e59bae22ae..7170e826cb2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "zeppelin-solidity",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -42,6 +42,23 @@
         }
       }
     },
+    "acorn-jsx": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz",
+      "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=",
+      "dev": true,
+      "requires": {
+        "acorn": "3.3.0"
+      },
+      "dependencies": {
+        "acorn": {
+          "version": "3.3.0",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz",
+          "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=",
+          "dev": true
+        }
+      }
+    },
     "aes-js": {
       "version": "0.2.4",
       "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-0.2.4.tgz",
@@ -83,6 +100,12 @@
       "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=",
       "dev": true
     },
+    "ansi-escapes": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.0.0.tgz",
+      "integrity": "sha512-O/klc27mWNUigtv0F8NJWbLF00OcegQalkqKURWdosW08YZKi4m6CnSUSvIZG1otNJbTWhN01Hhz389DW7mvDQ==",
+      "dev": true
+    },
     "ansi-regex": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
@@ -98,7 +121,7 @@
     "anymatch": {
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz",
-      "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==",
+      "integrity": "sha1-VT3Lj5HjyImEXf26NMd3IbkLnXo=",
       "dev": true,
       "requires": {
         "micromatch": "2.3.11",
@@ -142,7 +165,22 @@
     "arr-flatten": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz",
-      "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==",
+      "integrity": "sha1-NgSLv/TntH4TZkQxbJlmnqWukfE=",
+      "dev": true
+    },
+    "array-union": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz",
+      "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=",
+      "dev": true,
+      "requires": {
+        "array-uniq": "1.0.3"
+      }
+    },
+    "array-uniq": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz",
+      "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=",
       "dev": true
     },
     "array-unique": {
@@ -151,6 +189,12 @@
       "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
       "dev": true
     },
+    "arrify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
+      "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
+      "dev": true
+    },
     "asn1": {
       "version": "0.2.3",
       "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz",
@@ -1014,7 +1058,7 @@
     "base64-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.1.tgz",
-      "integrity": "sha512-dwVUVIXsBZXwTuwnXI9RK8sBmgq09NDHzyR9SAph9eqk76gKK2JSQmZARC2zRC81JC2QTtxD0ARU5qTS25gIGw==",
+      "integrity": "sha1-qRlH2h9KUW6jjltOwOw3c2deCIY=",
       "dev": true
     },
     "bcrypt-pbkdf": {
@@ -1042,7 +1086,7 @@
     "bindings": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.0.tgz",
-      "integrity": "sha512-DpLh5EzMR2kzvX1KIlVC0VkC3iZtHKTgdtZ0a3pglBZdaQFjt5S9g9xd1lE+YvXyfd6mtCeRnrUfOLYiTMlNSw==",
+      "integrity": "sha1-s0b27PapX1qBXFg5/HzbIlAvHtc=",
       "dev": true
     },
     "bip39": {
@@ -1078,7 +1122,7 @@
     "bn.js": {
       "version": "4.11.8",
       "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
-      "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
+      "integrity": "sha1-LN4J617jQfSEdGuwMJsyU7GxRC8=",
       "dev": true
     },
     "boom": {
@@ -1249,6 +1293,21 @@
       "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=",
       "dev": true
     },
+    "caller-path": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz",
+      "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=",
+      "dev": true,
+      "requires": {
+        "callsites": "0.2.0"
+      }
+    },
+    "callsites": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz",
+      "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=",
+      "dev": true
+    },
     "camelcase": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz",
@@ -1288,7 +1347,7 @@
     "chai-as-promised": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/chai-as-promised/-/chai-as-promised-7.1.1.tgz",
-      "integrity": "sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==",
+      "integrity": "sha1-CGRdgl3rhpbuYXJdv1kMAS6wDKA=",
       "dev": true,
       "requires": {
         "check-error": "1.0.2"
@@ -1313,6 +1372,12 @@
         "supports-color": "2.0.0"
       }
     },
+    "chardet": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz",
+      "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=",
+      "dev": true
+    },
     "check-error": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz",
@@ -1336,6 +1401,7 @@
       "requires": {
         "anymatch": "1.3.2",
         "async-each": "1.0.1",
+        "fsevents": "1.1.3",
         "glob-parent": "2.0.0",
         "inherits": "2.0.3",
         "is-binary-path": "1.0.1",
@@ -1353,13 +1419,34 @@
     "cipher-base": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz",
-      "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
+      "integrity": "sha1-h2Dk7MJy9MNjUy+SbYdKriwTl94=",
       "dev": true,
       "requires": {
         "inherits": "2.0.3",
         "safe-buffer": "5.1.1"
       }
     },
+    "circular-json": {
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz",
+      "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==",
+      "dev": true
+    },
+    "cli-cursor": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz",
+      "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=",
+      "dev": true,
+      "requires": {
+        "restore-cursor": "2.0.0"
+      }
+    },
+    "cli-width": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz",
+      "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=",
+      "dev": true
+    },
     "cliui": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz",
@@ -1407,6 +1494,21 @@
         }
       }
     },
+    "color-convert": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.1.tgz",
+      "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
     "combined-stream": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.5.tgz",
@@ -1428,6 +1530,17 @@
       "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
       "dev": true
     },
+    "concat-stream": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz",
+      "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=",
+      "dev": true,
+      "requires": {
+        "inherits": "2.0.3",
+        "readable-stream": "2.3.3",
+        "typedarray": "0.0.6"
+      }
+    },
     "console-browserify": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz",
@@ -1449,6 +1562,12 @@
       "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=",
       "dev": true
     },
+    "contains-path": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz",
+      "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=",
+      "dev": true
+    },
     "convert-source-map": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.0.tgz",
@@ -1671,7 +1790,7 @@
     "deferred-leveldown": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-1.2.2.tgz",
-      "integrity": "sha512-uukrWD2bguRtXilKt6cAWKyoXrTSMo5m7crUdLfWQmu8kIm88w3QZoUL+6nhpfKVmhHANER6Re3sKoNoZ3IKMA==",
+      "integrity": "sha1-Os0uC3XRZpkkvApLZChRExFz4es=",
       "dev": true,
       "requires": {
         "abstract-leveldown": "2.6.2"
@@ -1701,6 +1820,21 @@
       "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
       "dev": true
     },
+    "del": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz",
+      "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=",
+      "dev": true,
+      "requires": {
+        "globby": "5.0.0",
+        "is-path-cwd": "1.0.0",
+        "is-path-in-cwd": "1.0.0",
+        "object-assign": "4.1.1",
+        "pify": "2.3.0",
+        "pinkie-promise": "2.0.1",
+        "rimraf": "2.6.1"
+      }
+    },
     "delayed-stream": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
@@ -1749,6 +1883,15 @@
         "randombytes": "2.0.5"
       }
     },
+    "doctrine": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.0.2.tgz",
+      "integrity": "sha512-y0tm5Pq6ywp3qSTZ1vPgVdAnbDEoeoc5wlOHXoY1c4Wug/a7JvqHIl7BTvwodaHmejWkK/9dSb3sCYfyo/om8A==",
+      "dev": true,
+      "requires": {
+        "esutils": "2.0.2"
+      }
+    },
     "dom-walk": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.1.tgz",
@@ -1761,6 +1904,11 @@
       "integrity": "sha1-hnqksJP6oF8d4IwG9NeyH9+GmLw=",
       "dev": true
     },
+    "dotenv": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-4.0.0.tgz",
+      "integrity": "sha1-hk7xN5rO1Vzm+V3r7NzhefegzR0="
+    },
     "drbg.js": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz",
@@ -2004,143 +2152,487 @@
         }
       }
     },
-    "esprima": {
-      "version": "2.7.3",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
-      "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
-      "dev": true
-    },
-    "esrecurse": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.0.tgz",
-      "integrity": "sha1-+pVo2Y04I/mkHZHpAtyrnqblsWM=",
+    "eslint": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.12.0.tgz",
+      "integrity": "sha512-Ohv4NU0FffkEe4so8DBrdfRUbGUtM4XnBTDll2pY7OdW3VkjBOZPerx3Bmuhg6S6D6r8+cli0EezN0xawUfYwg==",
       "dev": true,
       "requires": {
+        "ajv": "5.5.0",
+        "babel-code-frame": "6.22.0",
+        "chalk": "2.3.0",
+        "concat-stream": "1.6.0",
+        "cross-spawn": "5.1.0",
+        "debug": "3.1.0",
+        "doctrine": "2.0.2",
+        "eslint-scope": "3.7.1",
+        "espree": "3.5.2",
+        "esquery": "1.0.0",
         "estraverse": "4.2.0",
-        "object-assign": "4.1.1"
+        "esutils": "2.0.2",
+        "file-entry-cache": "2.0.0",
+        "functional-red-black-tree": "1.0.1",
+        "glob": "7.1.2",
+        "globals": "11.0.1",
+        "ignore": "3.3.7",
+        "imurmurhash": "0.1.4",
+        "inquirer": "3.3.0",
+        "is-resolvable": "1.0.0",
+        "js-yaml": "3.10.0",
+        "json-stable-stringify-without-jsonify": "1.0.1",
+        "levn": "0.3.0",
+        "lodash": "4.17.4",
+        "minimatch": "3.0.4",
+        "mkdirp": "0.5.1",
+        "natural-compare": "1.4.0",
+        "optionator": "0.8.2",
+        "path-is-inside": "1.0.2",
+        "pluralize": "7.0.0",
+        "progress": "2.0.0",
+        "require-uncached": "1.0.3",
+        "semver": "5.4.1",
+        "strip-ansi": "4.0.0",
+        "strip-json-comments": "2.0.1",
+        "table": "4.0.2",
+        "text-table": "0.2.0"
       },
       "dependencies": {
+        "ajv": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.0.tgz",
+          "integrity": "sha1-6yhAdG6dxIvV4GOjbj/UAMXqtak=",
+          "dev": true,
+          "requires": {
+            "co": "4.6.0",
+            "fast-deep-equal": "1.0.0",
+            "fast-json-stable-stringify": "2.0.0",
+            "json-schema-traverse": "0.3.1"
+          }
+        },
+        "ansi-regex": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+          "dev": true
+        },
+        "ansi-styles": {
+          "version": "3.2.0",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz",
+          "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==",
+          "dev": true,
+          "requires": {
+            "color-convert": "1.9.1"
+          }
+        },
+        "chalk": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz",
+          "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "3.2.0",
+            "escape-string-regexp": "1.0.5",
+            "supports-color": "4.5.0"
+          }
+        },
+        "debug": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
+          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
+          "dev": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "esprima": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz",
+          "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==",
+          "dev": true
+        },
         "estraverse": {
           "version": "4.2.0",
           "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
           "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
           "dev": true
-        }
-      }
-    },
-    "estraverse": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz",
-      "integrity": "sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=",
-      "dev": true
-    },
-    "esutils": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
-      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
-      "dev": true
-    },
-    "ethereum-common": {
-      "version": "0.0.16",
-      "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.16.tgz",
-      "integrity": "sha1-mh4Wnq00q3XgifUMpRK/0PvRJlU=",
-      "dev": true
-    },
-    "ethereumjs-account": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/ethereumjs-account/-/ethereumjs-account-2.0.4.tgz",
-      "integrity": "sha1-+MMCMby3B/RRTYoFLB+doQNiTUc=",
-      "dev": true,
-      "requires": {
-        "ethereumjs-util": "4.5.0",
-        "rlp": "2.0.0"
-      },
-      "dependencies": {
-        "ethereumjs-util": {
+        },
+        "globals": {
+          "version": "11.0.1",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.0.1.tgz",
+          "integrity": "sha1-Eqh7sBDlFUOWrMU14eQ/x1Ow5eg=",
+          "dev": true
+        },
+        "has-flag": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz",
+          "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=",
+          "dev": true
+        },
+        "js-yaml": {
+          "version": "3.10.0",
+          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.10.0.tgz",
+          "integrity": "sha512-O2v52ffjLa9VeM43J4XocZE//WT9N0IiwDa3KSHH7Tu8CtH+1qM8SIZvnsTh6v+4yFy5KUY3BHUVwjpfAWsjIA==",
+          "dev": true,
+          "requires": {
+            "argparse": "1.0.9",
+            "esprima": "4.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "3.0.0"
+          }
+        },
+        "supports-color": {
           "version": "4.5.0",
-          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
-          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz",
+          "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=",
           "dev": true,
           "requires": {
-            "bn.js": "4.11.8",
-            "create-hash": "1.1.3",
-            "keccakjs": "0.2.1",
-            "rlp": "2.0.0",
-            "secp256k1": "3.3.0"
+            "has-flag": "2.0.0"
           }
         }
       }
     },
-    "ethereumjs-block": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/ethereumjs-block/-/ethereumjs-block-1.2.2.tgz",
-      "integrity": "sha1-LsdTSlkCG47JuDww5JaQxuuu3aE=",
+    "eslint-config-standard": {
+      "version": "10.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-config-standard/-/eslint-config-standard-10.2.1.tgz",
+      "integrity": "sha1-wGHk0GbzedwXzVYsZOgZtN1FRZE=",
+      "dev": true
+    },
+    "eslint-import-resolver-node": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.1.tgz",
+      "integrity": "sha512-yUtXS15gIcij68NmXmP9Ni77AQuCN0itXbCc/jWd8C6/yKZaSNXicpC8cgvjnxVdmfsosIXrjpzFq7GcDryb6A==",
       "dev": true,
       "requires": {
-        "async": "1.5.2",
-        "ethereum-common": "0.0.16",
-        "ethereumjs-tx": "1.1.2",
-        "ethereumjs-util": "4.5.0",
-        "merkle-patricia-tree": "2.1.2"
-      },
-      "dependencies": {
-        "ethereumjs-util": {
-          "version": "4.5.0",
-          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
-          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
-          "dev": true,
-          "requires": {
-            "bn.js": "4.11.8",
-            "create-hash": "1.1.3",
-            "keccakjs": "0.2.1",
-            "rlp": "2.0.0",
-            "secp256k1": "3.3.0"
-          }
-        }
+        "debug": "2.6.8",
+        "resolve": "1.4.0"
       }
     },
-    "ethereumjs-testrpc": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/ethereumjs-testrpc/-/ethereumjs-testrpc-6.0.1.tgz",
-      "integrity": "sha1-CdoVoUox2jhPsQwIwPqaxXasgTc=",
+    "eslint-module-utils": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.1.1.tgz",
+      "integrity": "sha512-jDI/X5l/6D1rRD/3T43q8Qgbls2nq5km5KSqiwlyUbGo5+04fXhMKdCPhjwbqAa6HXWaMxj8Q4hQDIh7IadJQw==",
       "dev": true,
       "requires": {
-        "webpack": "3.5.4"
+        "debug": "2.6.8",
+        "pkg-dir": "1.0.0"
       }
     },
-    "ethereumjs-tx": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-1.1.2.tgz",
-      "integrity": "sha1-wVFHfGIF0YYGAOKRCMPqyul+Kfo=",
+    "eslint-plugin-import": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.8.0.tgz",
+      "integrity": "sha512-Rf7dfKJxZ16QuTgVv1OYNxkZcsu/hULFnC+e+w0Gzi6jMC3guQoWQgxYxc54IDRinlb6/0v5z/PxxIKmVctN+g==",
       "dev": true,
       "requires": {
-        "ethereum-common": "0.0.17",
-        "ethereumjs-util": "4.5.0"
+        "builtin-modules": "1.1.1",
+        "contains-path": "0.1.0",
+        "debug": "2.6.8",
+        "doctrine": "1.5.0",
+        "eslint-import-resolver-node": "0.3.1",
+        "eslint-module-utils": "2.1.1",
+        "has": "1.0.1",
+        "lodash.cond": "4.5.2",
+        "minimatch": "3.0.4",
+        "read-pkg-up": "2.0.0"
       },
       "dependencies": {
-        "ethereum-common": {
-          "version": "0.0.17",
-          "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.17.tgz",
-          "integrity": "sha1-C1VMqdUSytyL4EVvvQAP/MOsT28=",
-          "dev": true
-        },
-        "ethereumjs-util": {
-          "version": "4.5.0",
-          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
-          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
+        "doctrine": {
+          "version": "1.5.0",
+          "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz",
+          "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=",
           "dev": true,
           "requires": {
-            "bn.js": "4.11.8",
-            "create-hash": "1.1.3",
-            "keccakjs": "0.2.1",
-            "rlp": "2.0.0",
-            "secp256k1": "3.3.0"
+            "esutils": "2.0.2",
+            "isarray": "1.0.0"
           }
-        }
-      }
-    },
-    "ethereumjs-util": {
-      "version": "5.1.2",
+        },
+        "find-up": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz",
+          "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=",
+          "dev": true,
+          "requires": {
+            "locate-path": "2.0.0"
+          }
+        },
+        "load-json-file": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz",
+          "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "4.1.11",
+            "parse-json": "2.2.0",
+            "pify": "2.3.0",
+            "strip-bom": "3.0.0"
+          }
+        },
+        "path-type": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz",
+          "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=",
+          "dev": true,
+          "requires": {
+            "pify": "2.3.0"
+          }
+        },
+        "read-pkg": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz",
+          "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=",
+          "dev": true,
+          "requires": {
+            "load-json-file": "2.0.0",
+            "normalize-package-data": "2.4.0",
+            "path-type": "2.0.0"
+          }
+        },
+        "read-pkg-up": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz",
+          "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=",
+          "dev": true,
+          "requires": {
+            "find-up": "2.1.0",
+            "read-pkg": "2.0.0"
+          }
+        },
+        "strip-bom": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+          "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=",
+          "dev": true
+        }
+      }
+    },
+    "eslint-plugin-node": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-node/-/eslint-plugin-node-5.2.1.tgz",
+      "integrity": "sha512-xhPXrh0Vl/b7870uEbaumb2Q+LxaEcOQ3kS1jtIXanBAwpMre1l5q/l2l/hESYJGEFKuI78bp6Uw50hlpr7B+g==",
+      "dev": true,
+      "requires": {
+        "ignore": "3.3.7",
+        "minimatch": "3.0.4",
+        "resolve": "1.4.0",
+        "semver": "5.3.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "5.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz",
+          "integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8=",
+          "dev": true
+        }
+      }
+    },
+    "eslint-plugin-promise": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-promise/-/eslint-plugin-promise-3.6.0.tgz",
+      "integrity": "sha512-YQzM6TLTlApAr7Li8vWKR+K3WghjwKcYzY0d2roWap4SLK+kzuagJX/leTetIDWsFcTFnKNJXWupDCD6aZkP2Q==",
+      "dev": true
+    },
+    "eslint-plugin-standard": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-standard/-/eslint-plugin-standard-3.0.1.tgz",
+      "integrity": "sha1-NNDJFbRe3G8BA5PH7vOCOwhWXPI=",
+      "dev": true
+    },
+    "eslint-scope": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz",
+      "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=",
+      "dev": true,
+      "requires": {
+        "esrecurse": "4.2.0",
+        "estraverse": "4.2.0"
+      },
+      "dependencies": {
+        "estraverse": {
+          "version": "4.2.0",
+          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
+          "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
+          "dev": true
+        }
+      }
+    },
+    "espree": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.2.tgz",
+      "integrity": "sha512-sadKeYwaR/aJ3stC2CdvgXu1T16TdYN+qwCpcWbMnGJ8s0zNWemzrvb2GbD4OhmJ/fwpJjudThAlLobGbWZbCQ==",
+      "dev": true,
+      "requires": {
+        "acorn": "5.2.1",
+        "acorn-jsx": "3.0.1"
+      },
+      "dependencies": {
+        "acorn": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.2.1.tgz",
+          "integrity": "sha512-jG0u7c4Ly+3QkkW18V+NRDN+4bWHdln30NL1ZL2AvFZZmQe/BfopYCtghCKKVBUSetZ4QKcyA0pY6/4Gw8Pv8w==",
+          "dev": true
+        }
+      }
+    },
+    "esprima": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
+      "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
+      "dev": true
+    },
+    "esquery": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.0.tgz",
+      "integrity": "sha1-z7qLV9f7qT8XKYqKAGoEzaE9gPo=",
+      "dev": true,
+      "requires": {
+        "estraverse": "4.2.0"
+      },
+      "dependencies": {
+        "estraverse": {
+          "version": "4.2.0",
+          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
+          "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
+          "dev": true
+        }
+      }
+    },
+    "esrecurse": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.0.tgz",
+      "integrity": "sha1-+pVo2Y04I/mkHZHpAtyrnqblsWM=",
+      "dev": true,
+      "requires": {
+        "estraverse": "4.2.0",
+        "object-assign": "4.1.1"
+      },
+      "dependencies": {
+        "estraverse": {
+          "version": "4.2.0",
+          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
+          "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
+          "dev": true
+        }
+      }
+    },
+    "estraverse": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz",
+      "integrity": "sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=",
+      "dev": true
+    },
+    "esutils": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
+      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
+      "dev": true
+    },
+    "ethereum-common": {
+      "version": "0.0.16",
+      "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.16.tgz",
+      "integrity": "sha1-mh4Wnq00q3XgifUMpRK/0PvRJlU=",
+      "dev": true
+    },
+    "ethereumjs-account": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/ethereumjs-account/-/ethereumjs-account-2.0.4.tgz",
+      "integrity": "sha1-+MMCMby3B/RRTYoFLB+doQNiTUc=",
+      "dev": true,
+      "requires": {
+        "ethereumjs-util": "4.5.0",
+        "rlp": "2.0.0"
+      },
+      "dependencies": {
+        "ethereumjs-util": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
+          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
+          "dev": true,
+          "requires": {
+            "bn.js": "4.11.8",
+            "create-hash": "1.1.3",
+            "keccakjs": "0.2.1",
+            "rlp": "2.0.0",
+            "secp256k1": "3.3.0"
+          }
+        }
+      }
+    },
+    "ethereumjs-block": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/ethereumjs-block/-/ethereumjs-block-1.2.2.tgz",
+      "integrity": "sha1-LsdTSlkCG47JuDww5JaQxuuu3aE=",
+      "dev": true,
+      "requires": {
+        "async": "1.5.2",
+        "ethereum-common": "0.0.16",
+        "ethereumjs-tx": "1.1.2",
+        "ethereumjs-util": "4.5.0",
+        "merkle-patricia-tree": "2.1.2"
+      },
+      "dependencies": {
+        "ethereumjs-util": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
+          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
+          "dev": true,
+          "requires": {
+            "bn.js": "4.11.8",
+            "create-hash": "1.1.3",
+            "keccakjs": "0.2.1",
+            "rlp": "2.0.0",
+            "secp256k1": "3.3.0"
+          }
+        }
+      }
+    },
+    "ethereumjs-testrpc": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/ethereumjs-testrpc/-/ethereumjs-testrpc-6.0.1.tgz",
+      "integrity": "sha1-CdoVoUox2jhPsQwIwPqaxXasgTc=",
+      "dev": true,
+      "requires": {
+        "webpack": "3.5.4"
+      }
+    },
+    "ethereumjs-tx": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-1.1.2.tgz",
+      "integrity": "sha1-wVFHfGIF0YYGAOKRCMPqyul+Kfo=",
+      "dev": true,
+      "requires": {
+        "ethereum-common": "0.0.17",
+        "ethereumjs-util": "4.5.0"
+      },
+      "dependencies": {
+        "ethereum-common": {
+          "version": "0.0.17",
+          "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.17.tgz",
+          "integrity": "sha1-C1VMqdUSytyL4EVvvQAP/MOsT28=",
+          "dev": true
+        },
+        "ethereumjs-util": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz",
+          "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=",
+          "dev": true,
+          "requires": {
+            "bn.js": "4.11.8",
+            "create-hash": "1.1.3",
+            "keccakjs": "0.2.1",
+            "rlp": "2.0.0",
+            "secp256k1": "3.3.0"
+          }
+        }
+      }
+    },
+    "ethereumjs-util": {
+      "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-5.1.2.tgz",
       "integrity": "sha1-JboCFcu0wvCxCKb5avKi5i5Fkh8=",
       "dev": true,
@@ -2316,6 +2808,17 @@
       "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=",
       "dev": true
     },
+    "external-editor": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.1.0.tgz",
+      "integrity": "sha512-E44iT5QVOUJBKij4IIV3uvxuNlbKS38Tw1HiupxEIHPv9qtC2PrDYohbXV5U+1jnfIXttny8gUhj+oZvflFlzA==",
+      "dev": true,
+      "requires": {
+        "chardet": "0.4.2",
+        "iconv-lite": "0.4.18",
+        "tmp": "0.0.33"
+      }
+    },
     "extglob": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
@@ -2346,12 +2849,37 @@
       "integrity": "sha1-liVqO8l1WV6zbYLpkp0GDYk0Of8=",
       "dev": true
     },
-    "fast-levenshtein": {
+    "fast-json-stable-stringify": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz",
+      "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=",
+      "dev": true
+    },
+    "fast-levenshtein": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
       "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
       "dev": true
     },
+    "figures": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
+      "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=",
+      "dev": true,
+      "requires": {
+        "escape-string-regexp": "1.0.5"
+      }
+    },
+    "file-entry-cache": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz",
+      "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=",
+      "dev": true,
+      "requires": {
+        "flat-cache": "1.3.0",
+        "object-assign": "4.1.1"
+      }
+    },
     "filename-regex": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz",
@@ -2381,6 +2909,18 @@
         "pinkie-promise": "2.0.1"
       }
     },
+    "flat-cache": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz",
+      "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=",
+      "dev": true,
+      "requires": {
+        "circular-json": "0.3.3",
+        "del": "2.2.2",
+        "graceful-fs": "4.1.11",
+        "write": "0.2.1"
+      }
+    },
     "for-each": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.2.tgz",
@@ -2447,6 +2987,910 @@
       "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
       "dev": true
     },
+    "fsevents": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.1.3.tgz",
+      "integrity": "sha512-WIr7iDkdmdbxu/Gh6eKEZJL6KPE74/5MEsf2whTOFNxbIoIixogroLdKYqB6FDav4Wavh/lZdzzd3b2KxIXC5Q==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "nan": "2.6.2",
+        "node-pre-gyp": "0.6.39"
+      },
+      "dependencies": {
+        "abbrev": {
+          "version": "1.1.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "ajv": {
+          "version": "4.11.8",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "co": "4.6.0",
+            "json-stable-stringify": "1.0.1"
+          }
+        },
+        "ansi-regex": {
+          "version": "2.1.1",
+          "bundled": true,
+          "dev": true
+        },
+        "aproba": {
+          "version": "1.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "are-we-there-yet": {
+          "version": "1.1.4",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "delegates": "1.0.0",
+            "readable-stream": "2.2.9"
+          }
+        },
+        "asn1": {
+          "version": "0.2.3",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "assert-plus": {
+          "version": "0.2.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "asynckit": {
+          "version": "0.4.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "aws-sign2": {
+          "version": "0.6.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "aws4": {
+          "version": "1.6.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "balanced-match": {
+          "version": "0.4.2",
+          "bundled": true,
+          "dev": true
+        },
+        "bcrypt-pbkdf": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "tweetnacl": "0.14.5"
+          }
+        },
+        "block-stream": {
+          "version": "0.0.9",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "inherits": "2.0.3"
+          }
+        },
+        "boom": {
+          "version": "2.10.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "hoek": "2.16.3"
+          }
+        },
+        "brace-expansion": {
+          "version": "1.1.7",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "balanced-match": "0.4.2",
+            "concat-map": "0.0.1"
+          }
+        },
+        "buffer-shims": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "caseless": {
+          "version": "0.12.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "co": {
+          "version": "4.6.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "code-point-at": {
+          "version": "1.1.0",
+          "bundled": true,
+          "dev": true
+        },
+        "combined-stream": {
+          "version": "1.0.5",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "delayed-stream": "1.0.0"
+          }
+        },
+        "concat-map": {
+          "version": "0.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "console-control-strings": {
+          "version": "1.1.0",
+          "bundled": true,
+          "dev": true
+        },
+        "core-util-is": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true
+        },
+        "cryptiles": {
+          "version": "2.0.5",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "boom": "2.10.1"
+          }
+        },
+        "dashdash": {
+          "version": "1.14.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "assert-plus": "1.0.0"
+          },
+          "dependencies": {
+            "assert-plus": {
+              "version": "1.0.0",
+              "bundled": true,
+              "dev": true,
+              "optional": true
+            }
+          }
+        },
+        "debug": {
+          "version": "2.6.8",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "deep-extend": {
+          "version": "0.4.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "delayed-stream": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "delegates": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "detect-libc": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "ecc-jsbn": {
+          "version": "0.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "jsbn": "0.1.1"
+          }
+        },
+        "extend": {
+          "version": "3.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "extsprintf": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true
+        },
+        "forever-agent": {
+          "version": "0.6.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "form-data": {
+          "version": "2.1.4",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "asynckit": "0.4.0",
+            "combined-stream": "1.0.5",
+            "mime-types": "2.1.15"
+          }
+        },
+        "fs.realpath": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "fstream": {
+          "version": "1.0.11",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "graceful-fs": "4.1.11",
+            "inherits": "2.0.3",
+            "mkdirp": "0.5.1",
+            "rimraf": "2.6.1"
+          }
+        },
+        "fstream-ignore": {
+          "version": "1.0.5",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "fstream": "1.0.11",
+            "inherits": "2.0.3",
+            "minimatch": "3.0.4"
+          }
+        },
+        "gauge": {
+          "version": "2.7.4",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "aproba": "1.1.1",
+            "console-control-strings": "1.1.0",
+            "has-unicode": "2.0.1",
+            "object-assign": "4.1.1",
+            "signal-exit": "3.0.2",
+            "string-width": "1.0.2",
+            "strip-ansi": "3.0.1",
+            "wide-align": "1.1.2"
+          }
+        },
+        "getpass": {
+          "version": "0.1.7",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "assert-plus": "1.0.0"
+          },
+          "dependencies": {
+            "assert-plus": {
+              "version": "1.0.0",
+              "bundled": true,
+              "dev": true,
+              "optional": true
+            }
+          }
+        },
+        "glob": {
+          "version": "7.1.2",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "fs.realpath": "1.0.0",
+            "inflight": "1.0.6",
+            "inherits": "2.0.3",
+            "minimatch": "3.0.4",
+            "once": "1.4.0",
+            "path-is-absolute": "1.0.1"
+          }
+        },
+        "graceful-fs": {
+          "version": "4.1.11",
+          "bundled": true,
+          "dev": true
+        },
+        "har-schema": {
+          "version": "1.0.5",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "har-validator": {
+          "version": "4.2.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "ajv": "4.11.8",
+            "har-schema": "1.0.5"
+          }
+        },
+        "has-unicode": {
+          "version": "2.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "hawk": {
+          "version": "3.1.3",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "boom": "2.10.1",
+            "cryptiles": "2.0.5",
+            "hoek": "2.16.3",
+            "sntp": "1.0.9"
+          }
+        },
+        "hoek": {
+          "version": "2.16.3",
+          "bundled": true,
+          "dev": true
+        },
+        "http-signature": {
+          "version": "1.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "assert-plus": "0.2.0",
+            "jsprim": "1.4.0",
+            "sshpk": "1.13.0"
+          }
+        },
+        "inflight": {
+          "version": "1.0.6",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "once": "1.4.0",
+            "wrappy": "1.0.2"
+          }
+        },
+        "inherits": {
+          "version": "2.0.3",
+          "bundled": true,
+          "dev": true
+        },
+        "ini": {
+          "version": "1.3.4",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "number-is-nan": "1.0.1"
+          }
+        },
+        "is-typedarray": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "isarray": {
+          "version": "1.0.0",
+          "bundled": true,
+          "dev": true
+        },
+        "isstream": {
+          "version": "0.1.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "jodid25519": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "jsbn": "0.1.1"
+          }
+        },
+        "jsbn": {
+          "version": "0.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "json-schema": {
+          "version": "0.2.3",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "json-stable-stringify": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "jsonify": "0.0.0"
+          }
+        },
+        "json-stringify-safe": {
+          "version": "5.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "jsonify": {
+          "version": "0.0.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "jsprim": {
+          "version": "1.4.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "assert-plus": "1.0.0",
+            "extsprintf": "1.0.2",
+            "json-schema": "0.2.3",
+            "verror": "1.3.6"
+          },
+          "dependencies": {
+            "assert-plus": {
+              "version": "1.0.0",
+              "bundled": true,
+              "dev": true,
+              "optional": true
+            }
+          }
+        },
+        "mime-db": {
+          "version": "1.27.0",
+          "bundled": true,
+          "dev": true
+        },
+        "mime-types": {
+          "version": "2.1.15",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "mime-db": "1.27.0"
+          }
+        },
+        "minimatch": {
+          "version": "3.0.4",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "brace-expansion": "1.1.7"
+          }
+        },
+        "minimist": {
+          "version": "0.0.8",
+          "bundled": true,
+          "dev": true
+        },
+        "mkdirp": {
+          "version": "0.5.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "minimist": "0.0.8"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "node-pre-gyp": {
+          "version": "0.6.39",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "detect-libc": "1.0.2",
+            "hawk": "3.1.3",
+            "mkdirp": "0.5.1",
+            "nopt": "4.0.1",
+            "npmlog": "4.1.0",
+            "rc": "1.2.1",
+            "request": "2.81.0",
+            "rimraf": "2.6.1",
+            "semver": "5.3.0",
+            "tar": "2.2.1",
+            "tar-pack": "3.4.0"
+          }
+        },
+        "nopt": {
+          "version": "4.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "abbrev": "1.1.0",
+            "osenv": "0.1.4"
+          }
+        },
+        "npmlog": {
+          "version": "4.1.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "are-we-there-yet": "1.1.4",
+            "console-control-strings": "1.1.0",
+            "gauge": "2.7.4",
+            "set-blocking": "2.0.0"
+          }
+        },
+        "number-is-nan": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "oauth-sign": {
+          "version": "0.8.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "object-assign": {
+          "version": "4.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "once": {
+          "version": "1.4.0",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "wrappy": "1.0.2"
+          }
+        },
+        "os-homedir": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "os-tmpdir": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "osenv": {
+          "version": "0.1.4",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "os-homedir": "1.0.2",
+            "os-tmpdir": "1.0.2"
+          }
+        },
+        "path-is-absolute": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "performance-now": {
+          "version": "0.2.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "process-nextick-args": {
+          "version": "1.0.7",
+          "bundled": true,
+          "dev": true
+        },
+        "punycode": {
+          "version": "1.4.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "qs": {
+          "version": "6.4.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "rc": {
+          "version": "1.2.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "deep-extend": "0.4.2",
+            "ini": "1.3.4",
+            "minimist": "1.2.0",
+            "strip-json-comments": "2.0.1"
+          },
+          "dependencies": {
+            "minimist": {
+              "version": "1.2.0",
+              "bundled": true,
+              "dev": true,
+              "optional": true
+            }
+          }
+        },
+        "readable-stream": {
+          "version": "2.2.9",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "buffer-shims": "1.0.0",
+            "core-util-is": "1.0.2",
+            "inherits": "2.0.3",
+            "isarray": "1.0.0",
+            "process-nextick-args": "1.0.7",
+            "string_decoder": "1.0.1",
+            "util-deprecate": "1.0.2"
+          }
+        },
+        "request": {
+          "version": "2.81.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "aws-sign2": "0.6.0",
+            "aws4": "1.6.0",
+            "caseless": "0.12.0",
+            "combined-stream": "1.0.5",
+            "extend": "3.0.1",
+            "forever-agent": "0.6.1",
+            "form-data": "2.1.4",
+            "har-validator": "4.2.1",
+            "hawk": "3.1.3",
+            "http-signature": "1.1.1",
+            "is-typedarray": "1.0.0",
+            "isstream": "0.1.2",
+            "json-stringify-safe": "5.0.1",
+            "mime-types": "2.1.15",
+            "oauth-sign": "0.8.2",
+            "performance-now": "0.2.0",
+            "qs": "6.4.0",
+            "safe-buffer": "5.0.1",
+            "stringstream": "0.0.5",
+            "tough-cookie": "2.3.2",
+            "tunnel-agent": "0.6.0",
+            "uuid": "3.0.1"
+          }
+        },
+        "rimraf": {
+          "version": "2.6.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "glob": "7.1.2"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.0.1",
+          "bundled": true,
+          "dev": true
+        },
+        "semver": {
+          "version": "5.3.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "set-blocking": {
+          "version": "2.0.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "signal-exit": {
+          "version": "3.0.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "sntp": {
+          "version": "1.0.9",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "hoek": "2.16.3"
+          }
+        },
+        "sshpk": {
+          "version": "1.13.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "asn1": "0.2.3",
+            "assert-plus": "1.0.0",
+            "bcrypt-pbkdf": "1.0.1",
+            "dashdash": "1.14.1",
+            "ecc-jsbn": "0.1.1",
+            "getpass": "0.1.7",
+            "jodid25519": "1.0.2",
+            "jsbn": "0.1.1",
+            "tweetnacl": "0.14.5"
+          },
+          "dependencies": {
+            "assert-plus": {
+              "version": "1.0.0",
+              "bundled": true,
+              "dev": true,
+              "optional": true
+            }
+          }
+        },
+        "string-width": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "code-point-at": "1.1.0",
+            "is-fullwidth-code-point": "1.0.0",
+            "strip-ansi": "3.0.1"
+          }
+        },
+        "string_decoder": {
+          "version": "1.0.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "safe-buffer": "5.0.1"
+          }
+        },
+        "stringstream": {
+          "version": "0.0.5",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "strip-ansi": {
+          "version": "3.0.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "ansi-regex": "2.1.1"
+          }
+        },
+        "strip-json-comments": {
+          "version": "2.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "tar": {
+          "version": "2.2.1",
+          "bundled": true,
+          "dev": true,
+          "requires": {
+            "block-stream": "0.0.9",
+            "fstream": "1.0.11",
+            "inherits": "2.0.3"
+          }
+        },
+        "tar-pack": {
+          "version": "3.4.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "debug": "2.6.8",
+            "fstream": "1.0.11",
+            "fstream-ignore": "1.0.5",
+            "once": "1.4.0",
+            "readable-stream": "2.2.9",
+            "rimraf": "2.6.1",
+            "tar": "2.2.1",
+            "uid-number": "0.0.6"
+          }
+        },
+        "tough-cookie": {
+          "version": "2.3.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "punycode": "1.4.1"
+          }
+        },
+        "tunnel-agent": {
+          "version": "0.6.0",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "safe-buffer": "5.0.1"
+          }
+        },
+        "tweetnacl": {
+          "version": "0.14.5",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "uid-number": {
+          "version": "0.0.6",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "util-deprecate": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true
+        },
+        "uuid": {
+          "version": "3.0.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true
+        },
+        "verror": {
+          "version": "1.3.6",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "extsprintf": "1.0.2"
+          }
+        },
+        "wide-align": {
+          "version": "1.1.2",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "string-width": "1.0.2"
+          }
+        },
+        "wrappy": {
+          "version": "1.0.2",
+          "bundled": true,
+          "dev": true
+        }
+      }
+    },
     "function-bind": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.0.tgz",
@@ -2577,9 +4021,23 @@
     "globals": {
       "version": "9.18.0",
       "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz",
-      "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==",
+      "integrity": "sha1-qjiWs+abSH8X4x7SFD1pqOMMLYo=",
       "dev": true
     },
+    "globby": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz",
+      "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=",
+      "dev": true,
+      "requires": {
+        "array-union": "1.0.2",
+        "arrify": "1.0.1",
+        "glob": "7.1.2",
+        "object-assign": "4.1.1",
+        "pify": "2.3.0",
+        "pinkie-promise": "2.0.1"
+      }
+    },
     "graceful-fs": {
       "version": "4.1.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz",
@@ -2675,7 +4133,7 @@
     "hash.js": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz",
-      "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==",
+      "integrity": "sha1-NA3tvmKQGHFRweodd3o0SJNd+EY=",
       "dev": true,
       "requires": {
         "inherits": "2.0.3",
@@ -2740,7 +4198,7 @@
     "hosted-git-info": {
       "version": "2.5.0",
       "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.5.0.tgz",
-      "integrity": "sha512-pNgbURSuab90KbTqvRPsseaTxOJCZBD0a7t+haSN33piP9cCM4l0CqdzAif2hUqm716UovKB2ROmiabGAKVXyg==",
+      "integrity": "sha1-bWDjSzq7yDEwYsO3mO+NkBoHrzw=",
       "dev": true
     },
     "http-signature": {
@@ -2772,12 +4230,24 @@
       "integrity": "sha1-vjPUCsEO8ZJnAfbwii2G+/0a0+Q=",
       "dev": true
     },
+    "ignore": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.7.tgz",
+      "integrity": "sha512-YGG3ejvBNHRqu0559EOxxNFihD0AjpvHlC/pdGKd3X3ofe+CoJkYazwNJYTNebqpPKN+VVQbh4ZFn1DivMNuHA==",
+      "dev": true
+    },
     "immediate": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.2.3.tgz",
       "integrity": "sha1-0UD6j2FGWb1lQSMwl92qwlzdmRw=",
       "dev": true
     },
+    "imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
+      "dev": true
+    },
     "indexof": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz",
@@ -2806,6 +4276,96 @@
       "integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4=",
       "dev": true
     },
+    "inquirer": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz",
+      "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==",
+      "dev": true,
+      "requires": {
+        "ansi-escapes": "3.0.0",
+        "chalk": "2.3.0",
+        "cli-cursor": "2.1.0",
+        "cli-width": "2.2.0",
+        "external-editor": "2.1.0",
+        "figures": "2.0.0",
+        "lodash": "4.17.4",
+        "mute-stream": "0.0.7",
+        "run-async": "2.3.0",
+        "rx-lite": "4.0.8",
+        "rx-lite-aggregates": "4.0.8",
+        "string-width": "2.1.1",
+        "strip-ansi": "4.0.0",
+        "through": "2.3.8"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+          "dev": true
+        },
+        "ansi-styles": {
+          "version": "3.2.0",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz",
+          "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==",
+          "dev": true,
+          "requires": {
+            "color-convert": "1.9.1"
+          }
+        },
+        "chalk": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz",
+          "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "3.2.0",
+            "escape-string-regexp": "1.0.5",
+            "supports-color": "4.5.0"
+          }
+        },
+        "has-flag": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz",
+          "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+          "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+          "dev": true,
+          "requires": {
+            "is-fullwidth-code-point": "2.0.0",
+            "strip-ansi": "4.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "3.0.0"
+          }
+        },
+        "supports-color": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz",
+          "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=",
+          "dev": true,
+          "requires": {
+            "has-flag": "2.0.0"
+          }
+        }
+      }
+    },
     "interpret": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.0.3.tgz",
@@ -2956,6 +4516,30 @@
         "kind-of": "3.2.2"
       }
     },
+    "is-path-cwd": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz",
+      "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=",
+      "dev": true
+    },
+    "is-path-in-cwd": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz",
+      "integrity": "sha1-ZHdYK4IU1gI0YJRWcAO+ip6sBNw=",
+      "dev": true,
+      "requires": {
+        "is-path-inside": "1.0.0"
+      }
+    },
+    "is-path-inside": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.0.tgz",
+      "integrity": "sha1-/AbloWg/vaE95mev9xe7wQpI838=",
+      "dev": true,
+      "requires": {
+        "path-is-inside": "1.0.2"
+      }
+    },
     "is-posix-bracket": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz",
@@ -2968,6 +4552,12 @@
       "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=",
       "dev": true
     },
+    "is-promise": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz",
+      "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=",
+      "dev": true
+    },
     "is-property": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
@@ -2983,6 +4573,15 @@
         "has": "1.0.1"
       }
     },
+    "is-resolvable": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.0.0.tgz",
+      "integrity": "sha1-jfV8YeouPFAUCNEA+wE8+NbgzGI=",
+      "dev": true,
+      "requires": {
+        "tryit": "1.0.3"
+      }
+    },
     "is-stream": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
@@ -3158,7 +4757,7 @@
     "json-loader": {
       "version": "0.5.7",
       "resolved": "https://registry.npmjs.org/json-loader/-/json-loader-0.5.7.tgz",
-      "integrity": "sha512-QLPs8Dj7lnf3e3QYS1zkCo+4ZwqOiF9d/nZnYozTISxXWCfNs9yuky5rJw4/W34s7POaNlbZmQGaB5NiXCbP4w==",
+      "integrity": "sha1-3KFKcCNf+C8KyaOr62DTN6NlGF0=",
       "dev": true
     },
     "json-schema": {
@@ -3182,6 +4781,12 @@
         "jsonify": "0.0.0"
       }
     },
+    "json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=",
+      "dev": true
+    },
     "json-stringify-safe": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
@@ -3244,7 +4849,7 @@
     "keccak": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/keccak/-/keccak-1.3.0.tgz",
-      "integrity": "sha512-JgsKPxYhcJxKrV+TrCyg/GwZbOjhpRPrz2kG8xbAsUaIDelUlKjm08YcwBO9Fm8sqf/Kg8ZWkk6nWujhLykfvw==",
+      "integrity": "sha1-NoG9ma09A1TdspuQQMG2VgzOCKw=",
       "dev": true,
       "requires": {
         "bindings": "1.3.0",
@@ -3404,7 +5009,7 @@
     "levelup": {
       "version": "1.3.9",
       "resolved": "https://registry.npmjs.org/levelup/-/levelup-1.3.9.tgz",
-      "integrity": "sha512-VVGHfKIlmw8w1XqpGOAGwq6sZm2WwWLmlDcULkKWQXEA5EopA8OBNJ2Ck2v6bdk8HeEZSbCSEgzXadyQFm76sQ==",
+      "integrity": "sha1-LbyuhFsrsra+qE3zNMR1Uzu9gqs=",
       "dev": true,
       "requires": {
         "deferred-leveldown": "1.2.2",
@@ -3520,6 +5125,12 @@
       "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=",
       "dev": true
     },
+    "lodash.cond": {
+      "version": "4.5.2",
+      "resolved": "https://registry.npmjs.org/lodash.cond/-/lodash.cond-4.5.2.tgz",
+      "integrity": "sha1-9HGh2khr5g9quVXRcRVSPdHSVdU=",
+      "dev": true
+    },
     "lodash.create": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz",
@@ -3743,7 +5354,7 @@
     "minimatch": {
       "version": "3.0.4",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "integrity": "sha1-UWbihkV/AzBgZL5Ul+jbsMPTIIM=",
       "dev": true,
       "requires": {
         "brace-expansion": "1.1.8"
@@ -3849,12 +5460,24 @@
       "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
       "dev": true
     },
+    "mute-stream": {
+      "version": "0.0.7",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz",
+      "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=",
+      "dev": true
+    },
     "nan": {
       "version": "2.6.2",
       "resolved": "https://registry.npmjs.org/nan/-/nan-2.6.2.tgz",
       "integrity": "sha1-5P805slf37WuzAjeZZb0NgWn20U=",
       "dev": true
     },
+    "natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
+      "dev": true
+    },
     "node-abi": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-2.1.0.tgz",
@@ -3934,7 +5557,7 @@
     "normalize-package-data": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
-      "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==",
+      "integrity": "sha1-EvlaMH1YNSB1oEkHuErIvpisAS8=",
       "dev": true,
       "requires": {
         "hosted-git-info": "2.5.0",
@@ -3964,7 +5587,7 @@
     "npmlog": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz",
-      "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==",
+      "integrity": "sha1-CKfyqL9zRgR3mp76StXMcXq7lUs=",
       "dev": true,
       "requires": {
         "are-we-there-yet": "1.1.4",
@@ -3994,7 +5617,7 @@
     "object-inspect": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.3.0.tgz",
-      "integrity": "sha512-OHHnLgLNXpM++GnJRyyhbr2bwl3pPVm4YvaraHrRvDt/N3r+s/gDVHciA7EJBTkijKXj61ssgSAikq1fb0IBRg==",
+      "integrity": "sha1-Wx645nQuLugzQqY3A02ESSi6L20=",
       "dev": true
     },
     "object-keys": {
@@ -4022,6 +5645,15 @@
         "wrappy": "1.0.2"
       }
     },
+    "onetime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
+      "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=",
+      "dev": true,
+      "requires": {
+        "mimic-fn": "1.1.0"
+      }
+    },
     "optimist": {
       "version": "0.6.1",
       "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz",
@@ -4179,6 +5811,12 @@
       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
       "dev": true
     },
+    "path-is-inside": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz",
+      "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=",
+      "dev": true
+    },
     "path-key": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
@@ -4248,6 +5886,21 @@
         "pinkie": "2.0.4"
       }
     },
+    "pkg-dir": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-1.0.0.tgz",
+      "integrity": "sha1-ektQio1bstYp1EcFb/TpyTFM89Q=",
+      "dev": true,
+      "requires": {
+        "find-up": "1.1.2"
+      }
+    },
+    "pluralize": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz",
+      "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==",
+      "dev": true
+    },
     "prebuild-install": {
       "version": "2.2.2",
       "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-2.2.2.tgz",
@@ -4317,6 +5970,12 @@
       "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=",
       "dev": true
     },
+    "progress": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.0.tgz",
+      "integrity": "sha1-ihvjZr+Pwj2yvSPxDG/pILQ4nR8=",
+      "dev": true
+    },
     "prr": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz",
@@ -4379,7 +6038,7 @@
     "randomatic": {
       "version": "1.1.7",
       "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-1.1.7.tgz",
-      "integrity": "sha512-D5JUjPyJbaJDkuAazpVnSfVkLlpeO3wDlPROTMLGKG1zMFNFRgrciKo1ltz/AzNTkqE0HzDx655QOL51N06how==",
+      "integrity": "sha1-x6vpzIuHwLqodrGf3oP9RkeX44w=",
       "dev": true,
       "requires": {
         "is-number": "3.0.0",
@@ -4420,7 +6079,7 @@
     "randombytes": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.5.tgz",
-      "integrity": "sha512-8T7Zn1AhMsQ/HI1SjcCfT/t4ii3eAqco3yOcSzS4mozsOz69lHLsoMXmF9nZgnFanYscnSlUSgs8uZyKzpE6kg==",
+      "integrity": "sha1-3ACaJGuNCaF3tLegrne8Vw9LG3k=",
       "dev": true,
       "requires": {
         "safe-buffer": "5.1.1"
@@ -4470,7 +6129,7 @@
     "readable-stream": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.3.tgz",
-      "integrity": "sha512-m+qzzcn7KUxEmd1gMbchF+Y2eIUbieUaxkWtptyHywrX0rE8QEYqPC07Vuy4Wm32/xE16NcdBctb8S0Xe/5IeQ==",
+      "integrity": "sha1-No8lEtefnUb9/HE0mueHi7weuVw=",
       "dev": true,
       "requires": {
         "core-util-is": "1.0.2",
@@ -4653,6 +6312,24 @@
       "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=",
       "dev": true
     },
+    "require-uncached": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz",
+      "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=",
+      "dev": true,
+      "requires": {
+        "caller-path": "0.1.0",
+        "resolve-from": "1.0.1"
+      },
+      "dependencies": {
+        "resolve-from": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz",
+          "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=",
+          "dev": true
+        }
+      }
+    },
     "resolve": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.4.0.tgz",
@@ -4668,6 +6345,16 @@
       "integrity": "sha1-lICrIOlP+h2egKgEx+oUdhGWa1c=",
       "dev": true
     },
+    "restore-cursor": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
+      "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=",
+      "dev": true,
+      "requires": {
+        "onetime": "2.0.1",
+        "signal-exit": "3.0.2"
+      }
+    },
     "resumer": {
       "version": "0.0.0",
       "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
@@ -4711,10 +6398,34 @@
       "integrity": "sha1-nbOE/0uJqPYVY9kjldhiWxjzr7A=",
       "dev": true
     },
+    "run-async": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz",
+      "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=",
+      "dev": true,
+      "requires": {
+        "is-promise": "2.1.0"
+      }
+    },
+    "rx-lite": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz",
+      "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=",
+      "dev": true
+    },
+    "rx-lite-aggregates": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz",
+      "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=",
+      "dev": true,
+      "requires": {
+        "rx-lite": "4.0.8"
+      }
+    },
     "safe-buffer": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz",
-      "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==",
+      "integrity": "sha1-iTMSr2myEj3vcfV4iQAWce6yyFM=",
       "dev": true
     },
     "scrypt": {
@@ -4765,13 +6476,13 @@
     "semaphore": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/semaphore/-/semaphore-1.1.0.tgz",
-      "integrity": "sha512-O4OZEaNtkMd/K0i6js9SL+gqy0ZCBMgUvlSqHKi4IBdjhe7wB8pwztUk1BbZ1fmrvpwFrPbHzqd2w5pTcJH6LA==",
+      "integrity": "sha1-qq2LhrIP6OmzKxbcLuaCqM0mqKo=",
       "dev": true
     },
     "semver": {
       "version": "5.4.1",
       "resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz",
-      "integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==",
+      "integrity": "sha1-4FnAnYVx8FQII3M0M1BdOi8AsY4=",
       "dev": true
     },
     "set-blocking": {
@@ -4865,6 +6576,23 @@
       "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
       "dev": true
     },
+    "slice-ansi": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz",
+      "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==",
+      "dev": true,
+      "requires": {
+        "is-fullwidth-code-point": "2.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        }
+      }
+    },
     "sntp": {
       "version": "1.0.9",
       "resolved": "https://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz",
@@ -4998,7 +6726,7 @@
     "source-list-map": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.0.tgz",
-      "integrity": "sha512-I2UmuJSRr/T8jisiROLU3A3ltr+swpniSmNPI4Ml3ZCX6tVnDsuZzK7F2hl5jTqbZBWCEKlj5HRQiPExXLgE8A==",
+      "integrity": "sha1-qqR0A/eyRakvvJfqCPJQ1gh+0IU=",
       "dev": true
     },
     "source-map": {
@@ -5080,7 +6808,7 @@
     "stream-http": {
       "version": "2.7.2",
       "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.7.2.tgz",
-      "integrity": "sha512-c0yTD2rbQzXtSsFSVhtpvY/vS6u066PcXOX9kBB3mSO76RiUQzL340uJkGBWnlBg4/HZzqiUXtaVA7wcRcJgEw==",
+      "integrity": "sha1-QKBQ7I3DtTsz2ZCUFcAsC/Gr+60=",
       "dev": true,
       "requires": {
         "builtin-status-codes": "3.0.0",
@@ -5115,7 +6843,7 @@
     "string_decoder": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz",
-      "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
+      "integrity": "sha1-D8Z9fBQYJd6UKC3VNr7GubzoYKs=",
       "dev": true,
       "requires": {
         "safe-buffer": "5.1.1"
@@ -5172,6 +6900,100 @@
       "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
       "dev": true
     },
+    "table": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz",
+      "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==",
+      "dev": true,
+      "requires": {
+        "ajv": "5.5.0",
+        "ajv-keywords": "2.1.0",
+        "chalk": "2.3.0",
+        "lodash": "4.17.4",
+        "slice-ansi": "1.0.0",
+        "string-width": "2.1.1"
+      },
+      "dependencies": {
+        "ajv": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.0.tgz",
+          "integrity": "sha1-6yhAdG6dxIvV4GOjbj/UAMXqtak=",
+          "dev": true,
+          "requires": {
+            "co": "4.6.0",
+            "fast-deep-equal": "1.0.0",
+            "fast-json-stable-stringify": "2.0.0",
+            "json-schema-traverse": "0.3.1"
+          }
+        },
+        "ansi-regex": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+          "dev": true
+        },
+        "ansi-styles": {
+          "version": "3.2.0",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz",
+          "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==",
+          "dev": true,
+          "requires": {
+            "color-convert": "1.9.1"
+          }
+        },
+        "chalk": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz",
+          "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "3.2.0",
+            "escape-string-regexp": "1.0.5",
+            "supports-color": "4.5.0"
+          }
+        },
+        "has-flag": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz",
+          "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+          "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+          "dev": true,
+          "requires": {
+            "is-fullwidth-code-point": "2.0.0",
+            "strip-ansi": "4.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "3.0.0"
+          }
+        },
+        "supports-color": {
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz",
+          "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=",
+          "dev": true,
+          "requires": {
+            "has-flag": "2.0.0"
+          }
+        }
+      }
+    },
     "tapable": {
       "version": "0.2.8",
       "resolved": "https://registry.npmjs.org/tapable/-/tapable-0.2.8.tgz",
@@ -5181,7 +7003,7 @@
     "tape": {
       "version": "4.8.0",
       "resolved": "https://registry.npmjs.org/tape/-/tape-4.8.0.tgz",
-      "integrity": "sha512-TWILfEnvO7I8mFe35d98F6T5fbLaEtbFTG/lxWvid8qDfFTxt19EBijWmB4j3+Hoh5TfHE2faWs73ua+EphuBA==",
+      "integrity": "sha1-9qn+xBzFCh3lD6M2A6tYCZH2Bo4=",
       "dev": true,
       "requires": {
         "deep-equal": "1.0.1",
@@ -5231,6 +7053,12 @@
         "xtend": "4.0.1"
       }
     },
+    "text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
+      "dev": true
+    },
     "through": {
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
@@ -5247,6 +7075,15 @@
         "setimmediate": "1.0.5"
       }
     },
+    "tmp": {
+      "version": "0.0.33",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
+      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
+      "dev": true,
+      "requires": {
+        "os-tmpdir": "1.0.2"
+      }
+    },
     "to-arraybuffer": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz",
@@ -5289,7 +7126,7 @@
     "truffle": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/truffle/-/truffle-4.0.1.tgz",
-      "integrity": "sha512-PybO+GMq3AvsfCWfEx4sbuaJlDL19iR8Ff20cO0TtP599N5JbMLlhwlffvVInPgFjP+F11vjSOYj3hT8fONs5A==",
+      "integrity": "sha1-2GYaStemyglLdRfSmxmcYObd5mU=",
       "dev": true,
       "requires": {
         "mocha": "3.5.3",
@@ -5329,7 +7166,7 @@
         "mocha": {
           "version": "3.5.3",
           "resolved": "https://registry.npmjs.org/mocha/-/mocha-3.5.3.tgz",
-          "integrity": "sha512-/6na001MJWEtYxHOV1WLfsmR4YIynkUEhBwzsb+fk2qmQ3iqsi258l/Q2MWHJMImAcNpZ8DEdYAK72NHoIQ9Eg==",
+          "integrity": "sha1-HgSA/jbS2lhY0etqzDhBiybqog0=",
           "dev": true,
           "requires": {
             "browser-stdout": "1.3.0",
@@ -5466,6 +7303,12 @@
         }
       }
     },
+    "tryit": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/tryit/-/tryit-1.0.3.tgz",
+      "integrity": "sha1-OTvnMKlEb9Hq1tpZoBQwjzbCics=",
+      "dev": true
+    },
     "tty-browserify": {
       "version": "0.0.0",
       "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz",
@@ -5500,6 +7343,12 @@
       "integrity": "sha1-Dj8mcLRAmbC0bChNE2p+9Jx0wuo=",
       "dev": true
     },
+    "typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=",
+      "dev": true
+    },
     "uglify-js": {
       "version": "2.8.29",
       "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz",
@@ -5634,7 +7483,7 @@
     "uuid": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.1.0.tgz",
-      "integrity": "sha512-DIWtzUkw04M4k3bf1IcpS2tngXEL26YUD2M0tMDUpnUrz2hgzUBlD55a4FjdLGPvfHxS6uluGWvaVEqgBcVa+g==",
+      "integrity": "sha1-PdPT55Crwk17DToDT/q6vijrvAQ=",
       "dev": true
     },
     "validate-npm-package-license": {
@@ -5913,7 +7762,7 @@
     "which": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz",
-      "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==",
+      "integrity": "sha1-/wS9/AEO5UfXgL7DjhrBwnd9JTo=",
       "dev": true,
       "requires": {
         "isexe": "2.0.0"
@@ -5928,7 +7777,7 @@
     "wide-align": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.2.tgz",
-      "integrity": "sha512-ijDLlyQ7s6x1JgCLur53osjm/UXUYD9+0PbYKrBsYisYXzCxN+HC3mYDNy/dWdmf3AwqwU3CXwDCvsNgGK1S0w==",
+      "integrity": "sha1-Vx4PGwYEY268DfwhsDObvjE0FxA=",
       "dev": true,
       "requires": {
         "string-width": "1.0.2"
@@ -5962,6 +7811,15 @@
       "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
       "dev": true
     },
+    "write": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz",
+      "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=",
+      "dev": true,
+      "requires": {
+        "mkdirp": "0.5.1"
+      }
+    },
     "xhr": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/xhr/-/xhr-2.4.0.tgz",
diff --git a/test/BasicToken.test.js b/test/BasicToken.test.js
index c7f406d74b5..9775b704068 100644
--- a/test/BasicToken.test.js
+++ b/test/BasicToken.test.js
@@ -1,43 +1,43 @@
-const assertRevert = require('./helpers/assertRevert')
+const assertRevert = require('./helpers/assertRevert');
 
-var BasicTokenMock = artifacts.require('./mocks/BasicTokenMock.sol')
+var BasicTokenMock = artifacts.require('./mocks/BasicTokenMock.sol');
 
 contract('BasicToken', function (accounts) {
   it('should return the correct totalSupply after construction', async function () {
-    let token = await BasicTokenMock.new(accounts[0], 100)
-    let totalSupply = await token.totalSupply()
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    let totalSupply = await token.totalSupply();
 
-    assert.equal(totalSupply, 100)
-  })
+    assert.equal(totalSupply, 100);
+  });
 
   it('should return correct balances after transfer', async function () {
-    let token = await BasicTokenMock.new(accounts[0], 100)
-    await token.transfer(accounts[1], 100)
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    await token.transfer(accounts[1], 100);
 
-    let firstAccountBalance = await token.balanceOf(accounts[0])
-    assert.equal(firstAccountBalance, 0)
+    let firstAccountBalance = await token.balanceOf(accounts[0]);
+    assert.equal(firstAccountBalance, 0);
 
-    let secondAccountBalance = await token.balanceOf(accounts[1])
-    assert.equal(secondAccountBalance, 100)
-  })
+    let secondAccountBalance = await token.balanceOf(accounts[1]);
+    assert.equal(secondAccountBalance, 100);
+  });
 
   it('should throw an error when trying to transfer more than balance', async function () {
-    let token = await BasicTokenMock.new(accounts[0], 100)
+    let token = await BasicTokenMock.new(accounts[0], 100);
     try {
-      await token.transfer(accounts[1], 101)
-      assert.fail('should have thrown before')
+      await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should throw an error when trying to transfer to 0x0', async function () {
-    let token = await BasicTokenMock.new(accounts[0], 100)
+    let token = await BasicTokenMock.new(accounts[0], 100);
     try {
-      await token.transfer(0x0, 100)
-      assert.fail('should have thrown before')
+      await token.transfer(0x0, 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/Bounty.test.js b/test/Bounty.test.js
index fb9e717897e..4ea34714f7e 100644
--- a/test/Bounty.test.js
+++ b/test/Bounty.test.js
@@ -4,108 +4,108 @@ let sendReward = function (sender, receiver, value) {
     from: sender,
     to: receiver,
     value: value,
-  })
-}
-var SecureTargetBounty = artifacts.require('mocks/SecureTargetBounty.sol')
-var InsecureTargetBounty = artifacts.require('mocks/InsecureTargetBounty.sol')
+  });
+};
+var SecureTargetBounty = artifacts.require('mocks/SecureTargetBounty.sol');
+var InsecureTargetBounty = artifacts.require('mocks/InsecureTargetBounty.sol');
 
 function awaitEvent (event, handler) {
   return new Promise((resolve, reject) => {
     function wrappedHandler (...args) {
-      Promise.resolve(handler(...args)).then(resolve).catch(reject)
+      Promise.resolve(handler(...args)).then(resolve).catch(reject);
     }
 
-    event.watch(wrappedHandler)
-  })
+    event.watch(wrappedHandler);
+  });
 }
 
 contract('Bounty', function (accounts) {
   it('sets reward', async function () {
-    let owner = accounts[0]
-    let reward = web3.toWei(1, 'ether')
-    let bounty = await SecureTargetBounty.new()
-    sendReward(owner, bounty.address, reward)
+    let owner = accounts[0];
+    let reward = web3.toWei(1, 'ether');
+    let bounty = await SecureTargetBounty.new();
+    sendReward(owner, bounty.address, reward);
 
-    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
-  })
+    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
+  });
 
   it('empties itself when destroyed', async function () {
-    let owner = accounts[0]
-    let reward = web3.toWei(1, 'ether')
-    let bounty = await SecureTargetBounty.new()
-    sendReward(owner, bounty.address, reward)
+    let owner = accounts[0];
+    let reward = web3.toWei(1, 'ether');
+    let bounty = await SecureTargetBounty.new();
+    sendReward(owner, bounty.address, reward);
 
-    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
+    assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
 
-    await bounty.destroy()
-    assert.equal(0, web3.eth.getBalance(bounty.address).toNumber())
-  })
+    await bounty.destroy();
+    assert.equal(0, web3.eth.getBalance(bounty.address).toNumber());
+  });
 
   describe('Against secure contract', function () {
     it('cannot claim reward', async function () {
-      let owner = accounts[0]
-      let researcher = accounts[1]
-      let reward = web3.toWei(1, 'ether')
-      let bounty = await SecureTargetBounty.new()
-      let event = bounty.TargetCreated({})
+      let owner = accounts[0];
+      let researcher = accounts[1];
+      let reward = web3.toWei(1, 'ether');
+      let bounty = await SecureTargetBounty.new();
+      let event = bounty.TargetCreated({});
 
       let watcher = async function (err, result) {
-        event.stopWatching()
-        if (err) { throw err }
+        event.stopWatching();
+        if (err) { throw err; }
 
-        var targetAddress = result.args.createdAddress
-        sendReward(owner, bounty.address, reward)
+        var targetAddress = result.args.createdAddress;
+        sendReward(owner, bounty.address, reward);
 
         assert.equal(reward,
-          web3.eth.getBalance(bounty.address).toNumber())
+          web3.eth.getBalance(bounty.address).toNumber());
 
         try {
-          await bounty.claim(targetAddress, { from: researcher })
-          assert.isTrue(false) // should never reach here
+          await bounty.claim(targetAddress, { from: researcher });
+          assert.isTrue(false); // should never reach here
         } catch (error) {
-          let reClaimedBounty = await bounty.claimed.call()
-          assert.isFalse(reClaimedBounty)
+          let reClaimedBounty = await bounty.claimed.call();
+          assert.isFalse(reClaimedBounty);
         }
         try {
-          await bounty.withdrawPayments({ from: researcher })
-          assert.isTrue(false) // should never reach here
+          await bounty.withdrawPayments({ from: researcher });
+          assert.isTrue(false); // should never reach here
         } catch (err) {
           assert.equal(reward,
-            web3.eth.getBalance(bounty.address).toNumber())
+            web3.eth.getBalance(bounty.address).toNumber());
         }
-      }
-      bounty.createTarget({ from: researcher })
-      await awaitEvent(event, watcher)
-    })
-  })
+      };
+      bounty.createTarget({ from: researcher });
+      await awaitEvent(event, watcher);
+    });
+  });
 
   describe('Against broken contract', function () {
     it('claims reward', async function () {
-      let owner = accounts[0]
-      let researcher = accounts[1]
-      let reward = web3.toWei(1, 'ether')
-      let bounty = await InsecureTargetBounty.new()
-      let event = bounty.TargetCreated({})
+      let owner = accounts[0];
+      let researcher = accounts[1];
+      let reward = web3.toWei(1, 'ether');
+      let bounty = await InsecureTargetBounty.new();
+      let event = bounty.TargetCreated({});
 
       let watcher = async function (err, result) {
-        event.stopWatching()
-        if (err) { throw err }
-        let targetAddress = result.args.createdAddress
-        sendReward(owner, bounty.address, reward)
+        event.stopWatching();
+        if (err) { throw err; }
+        let targetAddress = result.args.createdAddress;
+        sendReward(owner, bounty.address, reward);
 
-        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber())
+        assert.equal(reward, web3.eth.getBalance(bounty.address).toNumber());
 
-        await bounty.claim(targetAddress, { from: researcher })
-        let claim = await bounty.claimed.call()
+        await bounty.claim(targetAddress, { from: researcher });
+        let claim = await bounty.claimed.call();
 
-        assert.isTrue(claim)
+        assert.isTrue(claim);
 
-        await bounty.withdrawPayments({ from: researcher })
+        await bounty.withdrawPayments({ from: researcher });
 
-        assert.equal(0, web3.eth.getBalance(bounty.address).toNumber())
-      }
-      bounty.createTarget({ from: researcher })
-      await awaitEvent(event, watcher)
-    })
-  })
-})
+        assert.equal(0, web3.eth.getBalance(bounty.address).toNumber());
+      };
+      bounty.createTarget({ from: researcher });
+      await awaitEvent(event, watcher);
+    });
+  });
+});
diff --git a/test/BurnableToken.test.js b/test/BurnableToken.test.js
index af0e3cc3c0c..51eee0d78a9 100644
--- a/test/BurnableToken.test.js
+++ b/test/BurnableToken.test.js
@@ -1,38 +1,38 @@
 
-const EVMRevert = require('./helpers/EVMRevert.js')
-const BurnableTokenMock = artifacts.require('./mocks/BurnableTokenMock.sol')
-const BigNumber = web3.BigNumber
+const EVMRevert = require('./helpers/EVMRevert.js');
+const BurnableTokenMock = artifacts.require('./mocks/BurnableTokenMock.sol');
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const expect = require('chai').expect
+const expect = require('chai').expect;
 
 contract('BurnableToken', function (accounts) {
-  let token
-  let expectedTokenSupply = new BigNumber(999)
+  let token;
+  let expectedTokenSupply = new BigNumber(999);
 
   beforeEach(async function () {
-    token = await BurnableTokenMock.new(accounts[0], 1000)
-  })
+    token = await BurnableTokenMock.new(accounts[0], 1000);
+  });
 
   it('owner should be able to burn tokens', async function () {
-    const { logs } = await token.burn(1, { from: accounts[0] })
+    const { logs } = await token.burn(1, { from: accounts[0] });
 
-    const balance = await token.balanceOf(accounts[0])
-    balance.should.be.bignumber.equal(expectedTokenSupply)
+    const balance = await token.balanceOf(accounts[0]);
+    balance.should.be.bignumber.equal(expectedTokenSupply);
 
-    const totalSupply = await token.totalSupply()
-    totalSupply.should.be.bignumber.equal(expectedTokenSupply)
+    const totalSupply = await token.totalSupply();
+    totalSupply.should.be.bignumber.equal(expectedTokenSupply);
 
-    const event = logs.find(e => e.event === 'Burn')
-    expect(event).to.exist
-  })
+    const event = logs.find(e => e.event === 'Burn');
+    expect(event).to.exist;
+  });
 
   it('cannot burn more tokens than your balance', async function () {
     await token.burn(2000, { from: accounts[0] })
-      .should.be.rejectedWith(EVMRevert)
-  })
-})
+      .should.be.rejectedWith(EVMRevert);
+  });
+});
diff --git a/test/CanReclaimToken.test.js b/test/CanReclaimToken.test.js
index 35d366d6c29..8a4b927934a 100644
--- a/test/CanReclaimToken.test.js
+++ b/test/CanReclaimToken.test.js
@@ -1,35 +1,35 @@
 
-import expectThrow from './helpers/expectThrow'
+import expectThrow from './helpers/expectThrow';
 
-const CanReclaimToken = artifacts.require('../contracts/ownership/CanReclaimToken.sol')
-const BasicTokenMock = artifacts.require('./mocks/BasicTokenMock.sol')
+const CanReclaimToken = artifacts.require('../contracts/ownership/CanReclaimToken.sol');
+const BasicTokenMock = artifacts.require('./mocks/BasicTokenMock.sol');
 
 contract('CanReclaimToken', function (accounts) {
-  let token = null
-  let canReclaimToken = null
+  let token = null;
+  let canReclaimToken = null;
 
   beforeEach(async function () {
     // Create contract and token
-    token = await BasicTokenMock.new(accounts[0], 100)
-    canReclaimToken = await CanReclaimToken.new()
+    token = await BasicTokenMock.new(accounts[0], 100);
+    canReclaimToken = await CanReclaimToken.new();
     // Force token into contract
-    await token.transfer(canReclaimToken.address, 10)
-    const startBalance = await token.balanceOf(canReclaimToken.address)
-    assert.equal(startBalance, 10)
-  })
+    await token.transfer(canReclaimToken.address, 10);
+    const startBalance = await token.balanceOf(canReclaimToken.address);
+    assert.equal(startBalance, 10);
+  });
 
   it('should allow owner to reclaim tokens', async function () {
-    const ownerStartBalance = await token.balanceOf(accounts[0])
-    await canReclaimToken.reclaimToken(token.address)
-    const ownerFinalBalance = await token.balanceOf(accounts[0])
-    const finalBalance = await token.balanceOf(canReclaimToken.address)
-    assert.equal(finalBalance, 0)
-    assert.equal(ownerFinalBalance - ownerStartBalance, 10)
-  })
+    const ownerStartBalance = await token.balanceOf(accounts[0]);
+    await canReclaimToken.reclaimToken(token.address);
+    const ownerFinalBalance = await token.balanceOf(accounts[0]);
+    const finalBalance = await token.balanceOf(canReclaimToken.address);
+    assert.equal(finalBalance, 0);
+    assert.equal(ownerFinalBalance - ownerStartBalance, 10);
+  });
 
   it('should allow only owner to reclaim tokens', async function () {
     await expectThrow(
       canReclaimToken.reclaimToken(token.address, { from: accounts[1] }),
-    )
-  })
-})
+    );
+  });
+});
diff --git a/test/CappedCrowdsale.test.js b/test/CappedCrowdsale.test.js
index 072fecf8d4d..c747fa21732 100644
--- a/test/CappedCrowdsale.test.js
+++ b/test/CappedCrowdsale.test.js
@@ -1,88 +1,88 @@
-import ether from './helpers/ether'
-import { advanceBlock } from './helpers/advanceToBlock'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
-import latestTime from './helpers/latestTime'
-import EVMRevert from './helpers/EVMRevert'
+import ether from './helpers/ether';
+import { advanceBlock } from './helpers/advanceToBlock';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
+import latestTime from './helpers/latestTime';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const CappedCrowdsale = artifacts.require('./mocks/CappedCrowdsaleImpl.sol')
-const MintableToken = artifacts.require('MintableToken')
+const CappedCrowdsale = artifacts.require('./mocks/CappedCrowdsaleImpl.sol');
+const MintableToken = artifacts.require('MintableToken');
 
 contract('CappedCrowdsale', function ([_, wallet]) {
-  const rate = new BigNumber(1000)
+  const rate = new BigNumber(1000);
 
-  const cap = ether(300)
-  const lessThanCap = ether(60)
+  const cap = ether(300);
+  const lessThanCap = ether(60);
 
   before(async function () {
     // Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
-    await advanceBlock()
-  })
+    await advanceBlock();
+  });
 
   beforeEach(async function () {
-    this.startTime = latestTime() + duration.weeks(1)
-    this.endTime = this.startTime + duration.weeks(1)
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime = this.startTime + duration.weeks(1);
 
-    this.crowdsale = await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, cap)
+    this.crowdsale = await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, cap);
 
-    this.token = MintableToken.at(await this.crowdsale.token())
-  })
+    this.token = MintableToken.at(await this.crowdsale.token());
+  });
 
   describe('creating a valid crowdsale', function () {
     it('should fail with zero cap', async function () {
-      await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, 0).should.be.rejectedWith(EVMRevert)
-    })
-  })
+      await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, 0).should.be.rejectedWith(EVMRevert);
+    });
+  });
 
   describe('accepting payments', function () {
     beforeEach(async function () {
-      await increaseTimeTo(this.startTime)
-    })
+      await increaseTimeTo(this.startTime);
+    });
 
     it('should accept payments within cap', async function () {
-      await this.crowdsale.send(cap.minus(lessThanCap)).should.be.fulfilled
-      await this.crowdsale.send(lessThanCap).should.be.fulfilled
-    })
+      await this.crowdsale.send(cap.minus(lessThanCap)).should.be.fulfilled;
+      await this.crowdsale.send(lessThanCap).should.be.fulfilled;
+    });
 
     it('should reject payments outside cap', async function () {
-      await this.crowdsale.send(cap)
-      await this.crowdsale.send(1).should.be.rejectedWith(EVMRevert)
-    })
+      await this.crowdsale.send(cap);
+      await this.crowdsale.send(1).should.be.rejectedWith(EVMRevert);
+    });
 
     it('should reject payments that exceed cap', async function () {
-      await this.crowdsale.send(cap.plus(1)).should.be.rejectedWith(EVMRevert)
-    })
-  })
+      await this.crowdsale.send(cap.plus(1)).should.be.rejectedWith(EVMRevert);
+    });
+  });
 
   describe('ending', function () {
     beforeEach(async function () {
-      await increaseTimeTo(this.startTime)
-    })
+      await increaseTimeTo(this.startTime);
+    });
 
     it('should not be ended if under cap', async function () {
-      let hasEnded = await this.crowdsale.hasEnded()
-      hasEnded.should.equal(false)
-      await this.crowdsale.send(lessThanCap)
-      hasEnded = await this.crowdsale.hasEnded()
-      hasEnded.should.equal(false)
-    })
+      let hasEnded = await this.crowdsale.hasEnded();
+      hasEnded.should.equal(false);
+      await this.crowdsale.send(lessThanCap);
+      hasEnded = await this.crowdsale.hasEnded();
+      hasEnded.should.equal(false);
+    });
 
     it('should not be ended if just under cap', async function () {
-      await this.crowdsale.send(cap.minus(1))
-      let hasEnded = await this.crowdsale.hasEnded()
-      hasEnded.should.equal(false)
-    })
+      await this.crowdsale.send(cap.minus(1));
+      let hasEnded = await this.crowdsale.hasEnded();
+      hasEnded.should.equal(false);
+    });
 
     it('should be ended if cap reached', async function () {
-      await this.crowdsale.send(cap)
-      let hasEnded = await this.crowdsale.hasEnded()
-      hasEnded.should.equal(true)
-    })
-  })
-})
+      await this.crowdsale.send(cap);
+      let hasEnded = await this.crowdsale.hasEnded();
+      hasEnded.should.equal(true);
+    });
+  });
+});
diff --git a/test/CappedToken.test.js b/test/CappedToken.test.js
index 6055eb5b27d..d015c19118d 100644
--- a/test/CappedToken.test.js
+++ b/test/CappedToken.test.js
@@ -1,36 +1,36 @@
 
-import expectThrow from './helpers/expectThrow'
-import ether from './helpers/ether'
+import expectThrow from './helpers/expectThrow';
+import ether from './helpers/ether';
 
-var CappedToken = artifacts.require('../contracts/Tokens/CappedToken.sol')
+var CappedToken = artifacts.require('../contracts/Tokens/CappedToken.sol');
 
 contract('Capped', function (accounts) {
-  const cap = ether(1000)
+  const cap = ether(1000);
 
-  let token
+  let token;
 
   beforeEach(async function () {
-    token = await CappedToken.new(cap)
-  })
+    token = await CappedToken.new(cap);
+  });
 
   it('should start with the correct cap', async function () {
-    let _cap = await token.cap()
+    let _cap = await token.cap();
 
-    assert(cap.eq(_cap))
-  })
+    assert(cap.eq(_cap));
+  });
 
   it('should mint when amount is less than cap', async function () {
-    const result = await token.mint(accounts[0], 100)
-    assert.equal(result.logs[0].event, 'Mint')
-  })
+    const result = await token.mint(accounts[0], 100);
+    assert.equal(result.logs[0].event, 'Mint');
+  });
 
   it('should fail to mint if the ammount exceeds the cap', async function () {
-    await token.mint(accounts[0], cap.sub(1))
-    await expectThrow(token.mint(accounts[0], 100))
-  })
+    await token.mint(accounts[0], cap.sub(1));
+    await expectThrow(token.mint(accounts[0], 100));
+  });
 
   it('should fail to mint after cap is reached', async function () {
-    await token.mint(accounts[0], cap)
-    await expectThrow(token.mint(accounts[0], 1))
-  })
-})
+    await token.mint(accounts[0], cap);
+    await expectThrow(token.mint(accounts[0], 1));
+  });
+});
diff --git a/test/Claimable.test.js b/test/Claimable.test.js
index e29d76aa130..1004e512ced 100644
--- a/test/Claimable.test.js
+++ b/test/Claimable.test.js
@@ -1,62 +1,62 @@
 
-const assertRevert = require('./helpers/assertRevert')
+const assertRevert = require('./helpers/assertRevert');
 
-var Claimable = artifacts.require('../contracts/ownership/Claimable.sol')
+var Claimable = artifacts.require('../contracts/ownership/Claimable.sol');
 
 contract('Claimable', function (accounts) {
-  let claimable
+  let claimable;
 
   beforeEach(async function () {
-    claimable = await Claimable.new()
-  })
+    claimable = await Claimable.new();
+  });
 
   it('should have an owner', async function () {
-    let owner = await claimable.owner()
-    assert.isTrue(owner !== 0)
-  })
+    let owner = await claimable.owner();
+    assert.isTrue(owner !== 0);
+  });
 
   it('changes pendingOwner after transfer', async function () {
-    let newOwner = accounts[1]
-    await claimable.transferOwnership(newOwner)
-    let pendingOwner = await claimable.pendingOwner()
+    let newOwner = accounts[1];
+    await claimable.transferOwnership(newOwner);
+    let pendingOwner = await claimable.pendingOwner();
 
-    assert.isTrue(pendingOwner === newOwner)
-  })
+    assert.isTrue(pendingOwner === newOwner);
+  });
 
   it('should prevent to claimOwnership from no pendingOwner', async function () {
     try {
-      await claimable.claimOwnership({ from: accounts[2] })
-      assert.fail('should have thrown before')
+      await claimable.claimOwnership({ from: accounts[2] });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should prevent non-owners from transfering', async function () {
-    const other = accounts[2]
-    const owner = await claimable.owner.call()
-    assert.isTrue(owner !== other)
+    const other = accounts[2];
+    const owner = await claimable.owner.call();
+    assert.isTrue(owner !== other);
     try {
-      await claimable.transferOwnership(other, { from: other })
-      assert.fail('should have thrown before')
+      await claimable.transferOwnership(other, { from: other });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   describe('after initiating a transfer', function () {
-    let newOwner
+    let newOwner;
 
     beforeEach(async function () {
-      newOwner = accounts[1]
-      await claimable.transferOwnership(newOwner)
-    })
+      newOwner = accounts[1];
+      await claimable.transferOwnership(newOwner);
+    });
 
     it('changes allow pending owner to claim ownership', async function () {
-      await claimable.claimOwnership({ from: newOwner })
-      let owner = await claimable.owner()
+      await claimable.claimOwnership({ from: newOwner });
+      let owner = await claimable.owner();
 
-      assert.isTrue(owner === newOwner)
-    })
-  })
-})
+      assert.isTrue(owner === newOwner);
+    });
+  });
+});
diff --git a/test/Contactable.test.js b/test/Contactable.test.js
index 894abb30e3c..bb7f6d684ba 100644
--- a/test/Contactable.test.js
+++ b/test/Contactable.test.js
@@ -1,28 +1,28 @@
 
-var Contactable = artifacts.require('../contracts/ownership/Contactable.sol')
+var Contactable = artifacts.require('../contracts/ownership/Contactable.sol');
 
 contract('Contactable', function (accounts) {
-  let contactable
+  let contactable;
 
   beforeEach(async function () {
-    contactable = await Contactable.new()
-  })
+    contactable = await Contactable.new();
+  });
 
   it('should have an empty contact info', async function () {
-    let info = await contactable.contactInformation()
-    assert.isTrue(info === '')
-  })
+    let info = await contactable.contactInformation();
+    assert.isTrue(info === '');
+  });
 
   describe('after setting the contact information', function () {
-    let contactInfo = 'contact information'
+    let contactInfo = 'contact information';
 
     beforeEach(async function () {
-      await contactable.setContactInformation(contactInfo)
-    })
+      await contactable.setContactInformation(contactInfo);
+    });
 
     it('should return the setted contact information', async function () {
-      let info = await contactable.contactInformation()
-      assert.isTrue(info === contactInfo)
-    })
-  })
-})
+      let info = await contactable.contactInformation();
+      assert.isTrue(info === contactInfo);
+    });
+  });
+});
diff --git a/test/Crowdsale.test.js b/test/Crowdsale.test.js
index 079de8ea2a3..7d8555e5f11 100644
--- a/test/Crowdsale.test.js
+++ b/test/Crowdsale.test.js
@@ -1,143 +1,143 @@
-import ether from './helpers/ether'
-import { advanceBlock } from './helpers/advanceToBlock'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
-import latestTime from './helpers/latestTime'
-import EVMRevert from './helpers/EVMRevert'
+import ether from './helpers/ether';
+import { advanceBlock } from './helpers/advanceToBlock';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
+import latestTime from './helpers/latestTime';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 const should = require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const Crowdsale = artifacts.require('Crowdsale')
-const MintableToken = artifacts.require('MintableToken')
+const Crowdsale = artifacts.require('Crowdsale');
+const MintableToken = artifacts.require('MintableToken');
 
 contract('Crowdsale', function ([_, investor, wallet, purchaser]) {
-  const rate = new BigNumber(1000)
-  const value = ether(42)
+  const rate = new BigNumber(1000);
+  const value = ether(42);
 
-  const expectedTokenAmount = rate.mul(value)
+  const expectedTokenAmount = rate.mul(value);
 
   before(async function () {
     // Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
-    await advanceBlock()
-  })
+    await advanceBlock();
+  });
 
   beforeEach(async function () {
-    this.startTime = latestTime() + duration.weeks(1)
-    this.endTime = this.startTime + duration.weeks(1)
-    this.afterEndTime = this.endTime + duration.seconds(1)
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime = this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1);
 
-    this.crowdsale = await Crowdsale.new(this.startTime, this.endTime, rate, wallet)
+    this.crowdsale = await Crowdsale.new(this.startTime, this.endTime, rate, wallet);
 
-    this.token = MintableToken.at(await this.crowdsale.token())
-  })
+    this.token = MintableToken.at(await this.crowdsale.token());
+  });
 
   it('should be token owner', async function () {
-    const owner = await this.token.owner()
-    owner.should.equal(this.crowdsale.address)
-  })
+    const owner = await this.token.owner();
+    owner.should.equal(this.crowdsale.address);
+  });
 
   it('should be ended only after end', async function () {
-    let ended = await this.crowdsale.hasEnded()
-    ended.should.equal(false)
-    await increaseTimeTo(this.afterEndTime)
-    ended = await this.crowdsale.hasEnded()
-    ended.should.equal(true)
-  })
+    let ended = await this.crowdsale.hasEnded();
+    ended.should.equal(false);
+    await increaseTimeTo(this.afterEndTime);
+    ended = await this.crowdsale.hasEnded();
+    ended.should.equal(true);
+  });
 
   describe('accepting payments', function () {
     it('should reject payments before start', async function () {
-      await this.crowdsale.send(value).should.be.rejectedWith(EVMRevert)
-      await this.crowdsale.buyTokens(investor, { from: purchaser, value: value }).should.be.rejectedWith(EVMRevert)
-    })
+      await this.crowdsale.send(value).should.be.rejectedWith(EVMRevert);
+      await this.crowdsale.buyTokens(investor, { from: purchaser, value: value }).should.be.rejectedWith(EVMRevert);
+    });
 
     it('should accept payments after start', async function () {
-      await increaseTimeTo(this.startTime)
-      await this.crowdsale.send(value).should.be.fulfilled
-      await this.crowdsale.buyTokens(investor, { value: value, from: purchaser }).should.be.fulfilled
-    })
+      await increaseTimeTo(this.startTime);
+      await this.crowdsale.send(value).should.be.fulfilled;
+      await this.crowdsale.buyTokens(investor, { value: value, from: purchaser }).should.be.fulfilled;
+    });
 
     it('should reject payments after end', async function () {
-      await increaseTimeTo(this.afterEndTime)
-      await this.crowdsale.send(value).should.be.rejectedWith(EVMRevert)
-      await this.crowdsale.buyTokens(investor, { value: value, from: purchaser }).should.be.rejectedWith(EVMRevert)
-    })
-  })
+      await increaseTimeTo(this.afterEndTime);
+      await this.crowdsale.send(value).should.be.rejectedWith(EVMRevert);
+      await this.crowdsale.buyTokens(investor, { value: value, from: purchaser }).should.be.rejectedWith(EVMRevert);
+    });
+  });
 
   describe('high-level purchase', function () {
     beforeEach(async function () {
-      await increaseTimeTo(this.startTime)
-    })
+      await increaseTimeTo(this.startTime);
+    });
 
     it('should log purchase', async function () {
-      const { logs } = await this.crowdsale.sendTransaction({ value: value, from: investor })
+      const { logs } = await this.crowdsale.sendTransaction({ value: value, from: investor });
 
-      const event = logs.find(e => e.event === 'TokenPurchase')
+      const event = logs.find(e => e.event === 'TokenPurchase');
 
-      should.exist(event)
-      event.args.purchaser.should.equal(investor)
-      event.args.beneficiary.should.equal(investor)
-      event.args.value.should.be.bignumber.equal(value)
-      event.args.amount.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      should.exist(event);
+      event.args.purchaser.should.equal(investor);
+      event.args.beneficiary.should.equal(investor);
+      event.args.value.should.be.bignumber.equal(value);
+      event.args.amount.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should increase totalSupply', async function () {
-      await this.crowdsale.send(value)
-      const totalSupply = await this.token.totalSupply()
-      totalSupply.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      await this.crowdsale.send(value);
+      const totalSupply = await this.token.totalSupply();
+      totalSupply.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should assign tokens to sender', async function () {
-      await this.crowdsale.sendTransaction({ value: value, from: investor })
-      let balance = await this.token.balanceOf(investor)
-      balance.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      await this.crowdsale.sendTransaction({ value: value, from: investor });
+      let balance = await this.token.balanceOf(investor);
+      balance.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should forward funds to wallet', async function () {
-      const pre = web3.eth.getBalance(wallet)
-      await this.crowdsale.sendTransaction({ value, from: investor })
-      const post = web3.eth.getBalance(wallet)
-      post.minus(pre).should.be.bignumber.equal(value)
-    })
-  })
+      const pre = web3.eth.getBalance(wallet);
+      await this.crowdsale.sendTransaction({ value, from: investor });
+      const post = web3.eth.getBalance(wallet);
+      post.minus(pre).should.be.bignumber.equal(value);
+    });
+  });
 
   describe('low-level purchase', function () {
     beforeEach(async function () {
-      await increaseTimeTo(this.startTime)
-    })
+      await increaseTimeTo(this.startTime);
+    });
 
     it('should log purchase', async function () {
-      const { logs } = await this.crowdsale.buyTokens(investor, { value: value, from: purchaser })
+      const { logs } = await this.crowdsale.buyTokens(investor, { value: value, from: purchaser });
 
-      const event = logs.find(e => e.event === 'TokenPurchase')
+      const event = logs.find(e => e.event === 'TokenPurchase');
 
-      should.exist(event)
-      event.args.purchaser.should.equal(purchaser)
-      event.args.beneficiary.should.equal(investor)
-      event.args.value.should.be.bignumber.equal(value)
-      event.args.amount.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      should.exist(event);
+      event.args.purchaser.should.equal(purchaser);
+      event.args.beneficiary.should.equal(investor);
+      event.args.value.should.be.bignumber.equal(value);
+      event.args.amount.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should increase totalSupply', async function () {
-      await this.crowdsale.buyTokens(investor, { value, from: purchaser })
-      const totalSupply = await this.token.totalSupply()
-      totalSupply.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      await this.crowdsale.buyTokens(investor, { value, from: purchaser });
+      const totalSupply = await this.token.totalSupply();
+      totalSupply.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should assign tokens to beneficiary', async function () {
-      await this.crowdsale.buyTokens(investor, { value, from: purchaser })
-      const balance = await this.token.balanceOf(investor)
-      balance.should.be.bignumber.equal(expectedTokenAmount)
-    })
+      await this.crowdsale.buyTokens(investor, { value, from: purchaser });
+      const balance = await this.token.balanceOf(investor);
+      balance.should.be.bignumber.equal(expectedTokenAmount);
+    });
 
     it('should forward funds to wallet', async function () {
-      const pre = web3.eth.getBalance(wallet)
-      await this.crowdsale.buyTokens(investor, { value, from: purchaser })
-      const post = web3.eth.getBalance(wallet)
-      post.minus(pre).should.be.bignumber.equal(value)
-    })
-  })
-})
+      const pre = web3.eth.getBalance(wallet);
+      await this.crowdsale.buyTokens(investor, { value, from: purchaser });
+      const post = web3.eth.getBalance(wallet);
+      post.minus(pre).should.be.bignumber.equal(value);
+    });
+  });
+});
diff --git a/test/DayLimit.test.js b/test/DayLimit.test.js
index 9fe8a55ad1d..1378f862704 100644
--- a/test/DayLimit.test.js
+++ b/test/DayLimit.test.js
@@ -1,109 +1,109 @@
 
-import latestTime from './helpers/latestTime'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
+import latestTime from './helpers/latestTime';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
 
-const assertRevert = require('./helpers/assertRevert')
+const assertRevert = require('./helpers/assertRevert');
 
-const DayLimitMock = artifacts.require('./mocks/DayLimitMock.sol')
+const DayLimitMock = artifacts.require('./mocks/DayLimitMock.sol');
 
 contract('DayLimit', function (accounts) {
-  let dayLimit
-  let initLimit = 10
+  let dayLimit;
+  let initLimit = 10;
 
   beforeEach(async function () {
-    this.startTime = latestTime()
-    dayLimit = await DayLimitMock.new(initLimit)
-  })
+    this.startTime = latestTime();
+    dayLimit = await DayLimitMock.new(initLimit);
+  });
 
   it('should construct with the passed daily limit', async function () {
-    let dailyLimit = await dayLimit.dailyLimit()
-    assert.equal(initLimit, dailyLimit)
-  })
+    let dailyLimit = await dayLimit.dailyLimit();
+    assert.equal(initLimit, dailyLimit);
+  });
 
   it('should be able to spend if daily limit is not reached', async function () {
-    await dayLimit.attemptSpend(8)
-    let spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
-    await dayLimit.attemptSpend(2)
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 10)
-  })
+    await dayLimit.attemptSpend(2);
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 10);
+  });
 
   it('should prevent spending if daily limit is reached', async function () {
-    await dayLimit.attemptSpend(8)
-    let spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
     try {
-      await dayLimit.attemptSpend(3)
-      assert.fail('should have thrown before')
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should allow spending if daily limit is reached and then set higher', async function () {
-    await dayLimit.attemptSpend(8)
-    let spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
     try {
-      await dayLimit.attemptSpend(3)
-      assert.fail('should have thrown before')
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
-    await dayLimit.setDailyLimit(15)
-    await dayLimit.attemptSpend(3)
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 11)
-  })
+    await dayLimit.setDailyLimit(15);
+    await dayLimit.attemptSpend(3);
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 11);
+  });
 
   it('should allow spending if daily limit is reached and then amount spent is reset', async function () {
-    await dayLimit.attemptSpend(8)
-    let spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
     try {
-      await dayLimit.attemptSpend(3)
-      assert.fail('should have thrown before')
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
-    await dayLimit.resetSpentToday()
-    await dayLimit.attemptSpend(3)
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 3)
-  })
+    await dayLimit.resetSpentToday();
+    await dayLimit.attemptSpend(3);
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 3);
+  });
 
   it('should allow spending if daily limit is reached and then the next has come', async function () {
-    let limit = 10
-    let dayLimit = await DayLimitMock.new(limit)
+    let limit = 10;
+    let dayLimit = await DayLimitMock.new(limit);
 
-    await dayLimit.attemptSpend(8)
-    let spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
     try {
-      await dayLimit.attemptSpend(3)
-      assert.fail('should have thrown before')
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 8)
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
 
-    await increaseTimeTo(this.startTime + duration.days(1))
+    await increaseTimeTo(this.startTime + duration.days(1));
 
-    await dayLimit.attemptSpend(3)
-    spentToday = await dayLimit.spentToday()
-    assert.equal(spentToday, 3)
-  })
-})
+    await dayLimit.attemptSpend(3);
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 3);
+  });
+});
diff --git a/test/DelayedClaimble.test.js b/test/DelayedClaimble.test.js
index 2248776c451..8f7a8637d40 100644
--- a/test/DelayedClaimble.test.js
+++ b/test/DelayedClaimble.test.js
@@ -1,66 +1,66 @@
 
-var DelayedClaimable = artifacts.require('../contracts/ownership/DelayedClaimable.sol')
+var DelayedClaimable = artifacts.require('../contracts/ownership/DelayedClaimable.sol');
 
 contract('DelayedClaimable', function (accounts) {
-  var delayedClaimable
+  var delayedClaimable;
 
   beforeEach(function () {
     return DelayedClaimable.new().then(function (deployed) {
-      delayedClaimable = deployed
-    })
-  })
+      delayedClaimable = deployed;
+    });
+  });
 
   it('can set claim blocks', async function () {
-    await delayedClaimable.transferOwnership(accounts[2])
-    await delayedClaimable.setLimits(0, 1000)
-    let end = await delayedClaimable.end()
-    assert.equal(end, 1000)
-    let start = await delayedClaimable.start()
-    assert.equal(start, 0)
-  })
+    await delayedClaimable.transferOwnership(accounts[2]);
+    await delayedClaimable.setLimits(0, 1000);
+    let end = await delayedClaimable.end();
+    assert.equal(end, 1000);
+    let start = await delayedClaimable.start();
+    assert.equal(start, 0);
+  });
 
   it('changes pendingOwner after transfer successful', async function () {
-    await delayedClaimable.transferOwnership(accounts[2])
-    await delayedClaimable.setLimits(0, 1000)
-    let end = await delayedClaimable.end()
-    assert.equal(end, 1000)
-    let start = await delayedClaimable.start()
-    assert.equal(start, 0)
-    let pendingOwner = await delayedClaimable.pendingOwner()
-    assert.equal(pendingOwner, accounts[2])
-    await delayedClaimable.claimOwnership({ from: accounts[2] })
-    let owner = await delayedClaimable.owner()
-    assert.equal(owner, accounts[2])
-  })
+    await delayedClaimable.transferOwnership(accounts[2]);
+    await delayedClaimable.setLimits(0, 1000);
+    let end = await delayedClaimable.end();
+    assert.equal(end, 1000);
+    let start = await delayedClaimable.start();
+    assert.equal(start, 0);
+    let pendingOwner = await delayedClaimable.pendingOwner();
+    assert.equal(pendingOwner, accounts[2]);
+    await delayedClaimable.claimOwnership({ from: accounts[2] });
+    let owner = await delayedClaimable.owner();
+    assert.equal(owner, accounts[2]);
+  });
 
   it('changes pendingOwner after transfer fails', async function () {
-    await delayedClaimable.transferOwnership(accounts[1])
-    await delayedClaimable.setLimits(100, 110)
-    let end = await delayedClaimable.end()
-    assert.equal(end, 110)
-    let start = await delayedClaimable.start()
-    assert.equal(start, 100)
-    let pendingOwner = await delayedClaimable.pendingOwner()
-    assert.equal(pendingOwner, accounts[1])
-    var err = null
+    await delayedClaimable.transferOwnership(accounts[1]);
+    await delayedClaimable.setLimits(100, 110);
+    let end = await delayedClaimable.end();
+    assert.equal(end, 110);
+    let start = await delayedClaimable.start();
+    assert.equal(start, 100);
+    let pendingOwner = await delayedClaimable.pendingOwner();
+    assert.equal(pendingOwner, accounts[1]);
+    var err = null;
     try {
-      await delayedClaimable.claimOwnership({ from: accounts[1] })
+      await delayedClaimable.claimOwnership({ from: accounts[1] });
     } catch (error) {
-      err = error
+      err = error;
     }
-    assert.isFalse(err.message.search('revert') === -1)
-    let owner = await delayedClaimable.owner()
-    assert.isTrue(owner !== accounts[1])
-  })
+    assert.isFalse(err.message.search('revert') === -1);
+    let owner = await delayedClaimable.owner();
+    assert.isTrue(owner !== accounts[1]);
+  });
 
   it('set end and start invalid values fail', async function () {
-    await delayedClaimable.transferOwnership(accounts[1])
-    var err = null
+    await delayedClaimable.transferOwnership(accounts[1]);
+    var err = null;
     try {
-      await delayedClaimable.setLimits(1001, 1000)
+      await delayedClaimable.setLimits(1001, 1000);
     } catch (error) {
-      err = error
+      err = error;
     }
-    assert.isFalse(err.message.search('revert') === -1)
-  })
-})
+    assert.isFalse(err.message.search('revert') === -1);
+  });
+});
diff --git a/test/Destructible.test.js b/test/Destructible.test.js
index 8da8d493439..da02021f299 100644
--- a/test/Destructible.test.js
+++ b/test/Destructible.test.js
@@ -1,23 +1,23 @@
 
-var Destructible = artifacts.require('../contracts/lifecycle/Destructible.sol')
-require('./helpers/transactionMined.js')
+var Destructible = artifacts.require('../contracts/lifecycle/Destructible.sol');
+require('./helpers/transactionMined.js');
 
 contract('Destructible', function (accounts) {
   it('should send balance to owner after destruction', async function () {
-    let destructible = await Destructible.new({ from: accounts[0], value: web3.toWei('10', 'ether') })
-    let owner = await destructible.owner()
-    let initBalance = web3.eth.getBalance(owner)
-    await destructible.destroy({ from: owner })
-    let newBalance = web3.eth.getBalance(owner)
-    assert.isTrue(newBalance > initBalance)
-  })
+    let destructible = await Destructible.new({ from: accounts[0], value: web3.toWei('10', 'ether') });
+    let owner = await destructible.owner();
+    let initBalance = web3.eth.getBalance(owner);
+    await destructible.destroy({ from: owner });
+    let newBalance = web3.eth.getBalance(owner);
+    assert.isTrue(newBalance > initBalance);
+  });
 
   it('should send balance to recepient after destruction', async function () {
-    let destructible = await Destructible.new({ from: accounts[0], value: web3.toWei('10', 'ether') })
-    let owner = await destructible.owner()
-    let initBalance = web3.eth.getBalance(accounts[1])
-    await destructible.destroyAndSend(accounts[1], { from: owner })
-    let newBalance = web3.eth.getBalance(accounts[1])
-    assert.isTrue(newBalance.greaterThan(initBalance))
-  })
-})
+    let destructible = await Destructible.new({ from: accounts[0], value: web3.toWei('10', 'ether') });
+    let owner = await destructible.owner();
+    let initBalance = web3.eth.getBalance(accounts[1]);
+    await destructible.destroyAndSend(accounts[1], { from: owner });
+    let newBalance = web3.eth.getBalance(accounts[1]);
+    assert.isTrue(newBalance.greaterThan(initBalance));
+  });
+});
diff --git a/test/DetailedERC20.test.js b/test/DetailedERC20.test.js
index 060abe587cc..907129e6184 100644
--- a/test/DetailedERC20.test.js
+++ b/test/DetailedERC20.test.js
@@ -1,35 +1,35 @@
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const DetailedERC20Mock = artifacts.require('./mocks/DetailedERC20Mock.sol')
+const DetailedERC20Mock = artifacts.require('./mocks/DetailedERC20Mock.sol');
 
 contract('DetailedERC20', accounts => {
-  let detailedERC20 = null
+  let detailedERC20 = null;
 
-  const _name = 'My Detailed ERC20'
-  const _symbol = 'MDT'
-  const _decimals = 18
+  const _name = 'My Detailed ERC20';
+  const _symbol = 'MDT';
+  const _decimals = 18;
 
   beforeEach(async function () {
-    detailedERC20 = await DetailedERC20Mock.new(_name, _symbol, _decimals)
-  })
+    detailedERC20 = await DetailedERC20Mock.new(_name, _symbol, _decimals);
+  });
 
   it('has a name', async function () {
-    const name = await detailedERC20.name()
-    name.should.be.equal(_name)
-  })
+    const name = await detailedERC20.name();
+    name.should.be.equal(_name);
+  });
 
   it('has a symbol', async function () {
-    const symbol = await detailedERC20.symbol()
-    symbol.should.be.equal(_symbol)
-  })
+    const symbol = await detailedERC20.symbol();
+    symbol.should.be.equal(_symbol);
+  });
 
   it('has an amount of decimals', async function () {
-    const decimals = await detailedERC20.decimals()
-    decimals.should.be.bignumber.equal(_decimals)
-  })
-})
+    const decimals = await detailedERC20.decimals();
+    decimals.should.be.bignumber.equal(_decimals);
+  });
+});
diff --git a/test/ECRecovery.test.js b/test/ECRecovery.test.js
index 2c2d09c3be9..d59c29112a2 100644
--- a/test/ECRecovery.test.js
+++ b/test/ECRecovery.test.js
@@ -1,54 +1,54 @@
-var ECRecovery = artifacts.require('../contracts/ECRecovery.sol')
-var hashMessage = require('./helpers/hashMessage.js')
+var ECRecovery = artifacts.require('../contracts/ECRecovery.sol');
+var hashMessage = require('./helpers/hashMessage.js');
 
 contract('ECRecovery', function (accounts) {
-  let ecrecovery
+  let ecrecovery;
 
   before(async function () {
-    ecrecovery = await ECRecovery.new()
-  })
+    ecrecovery = await ECRecovery.new();
+  });
 
   it('recover v0', async function () {
     // Signature generated outside testrpc with method web3.eth.sign(signer, message)
-    let signer = '0x2cc1166f6212628a0deef2b33befb2187d35b86c'
-    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d' // web3.sha3('OpenZeppelin')
+    let signer = '0x2cc1166f6212628a0deef2b33befb2187d35b86c';
+    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d'; // web3.sha3('OpenZeppelin')
     // eslint-disable-next-line max-len
-    let signature = '0x5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be89200'
-    assert.equal(signer, await ecrecovery.recover(message, signature))
-  })
+    let signature = '0x5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be89200';
+    assert.equal(signer, await ecrecovery.recover(message, signature));
+  });
 
   it('recover v1', async function () {
     // Signature generated outside testrpc with method web3.eth.sign(signer, message)
-    let signer = '0x1e318623ab09fe6de3c9b8672098464aeda9100e'
-    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d' // web3.sha3('OpenZeppelin')
+    let signer = '0x1e318623ab09fe6de3c9b8672098464aeda9100e';
+    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d'; // web3.sha3('OpenZeppelin')
     // eslint-disable-next-line max-len
-    let signature = '0x331fe75a821c982f9127538858900d87d3ec1f9f737338ad67cad133fa48feff48e6fa0c18abc62e42820f05943e47af3e9fbe306ce74d64094bdf1691ee53e001'
-    assert.equal(signer, await ecrecovery.recover(message, signature))
-  })
+    let signature = '0x331fe75a821c982f9127538858900d87d3ec1f9f737338ad67cad133fa48feff48e6fa0c18abc62e42820f05943e47af3e9fbe306ce74d64094bdf1691ee53e001';
+    assert.equal(signer, await ecrecovery.recover(message, signature));
+  });
 
   it('recover using web3.eth.sign()', async function () {
     // Create the signature using account[0]
-    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'))
+    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
 
     // Recover the signer address form the generated message and signature.
-    assert.equal(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('OpenZeppelin'), signature))
-  })
+    assert.equal(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('OpenZeppelin'), signature));
+  });
 
   it('recover using web3.eth.sign() should return wrong signer', async function () {
     // Create the signature using account[0]
-    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'))
+    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
 
     // Recover the signer address form the generated message and wrong signature.
-    assert.notEqual(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('Test'), signature))
-  })
+    assert.notEqual(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('Test'), signature));
+  });
 
   it('recover should fail when a wrong hash is sent', async function () {
     // Create the signature using account[0]
-    let signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'))
+    let signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
 
     // Recover the signer address form the generated message and wrong signature.
     assert.equal('0x0000000000000000000000000000000000000000',
       await ecrecovery.recover(hashMessage('OpenZeppelin').substring(2), signature)
-    )
-  })
-})
+    );
+  });
+});
diff --git a/test/FinalizableCrowdsale.test.js b/test/FinalizableCrowdsale.test.js
index e37d70f13fb..8e9d6624142 100644
--- a/test/FinalizableCrowdsale.test.js
+++ b/test/FinalizableCrowdsale.test.js
@@ -1,60 +1,60 @@
-import { advanceBlock } from './helpers/advanceToBlock'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
-import latestTime from './helpers/latestTime'
-import EVMRevert from './helpers/EVMRevert'
+import { advanceBlock } from './helpers/advanceToBlock';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
+import latestTime from './helpers/latestTime';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 const should = require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const FinalizableCrowdsale = artifacts.require('./mocks/FinalizableCrowdsaleImpl.sol')
-const MintableToken = artifacts.require('MintableToken')
+const FinalizableCrowdsale = artifacts.require('./mocks/FinalizableCrowdsaleImpl.sol');
+const MintableToken = artifacts.require('MintableToken');
 
 contract('FinalizableCrowdsale', function ([_, owner, wallet, thirdparty]) {
-  const rate = new BigNumber(1000)
+  const rate = new BigNumber(1000);
 
   before(async function () {
     // Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
-    await advanceBlock()
-  })
+    await advanceBlock();
+  });
 
   beforeEach(async function () {
-    this.startTime = latestTime() + duration.weeks(1)
-    this.endTime = this.startTime + duration.weeks(1)
-    this.afterEndTime = this.endTime + duration.seconds(1)
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime = this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1);
 
-    this.crowdsale = await FinalizableCrowdsale.new(this.startTime, this.endTime, rate, wallet, { from: owner })
+    this.crowdsale = await FinalizableCrowdsale.new(this.startTime, this.endTime, rate, wallet, { from: owner });
 
-    this.token = MintableToken.at(await this.crowdsale.token())
-  })
+    this.token = MintableToken.at(await this.crowdsale.token());
+  });
 
   it('cannot be finalized before ending', async function () {
-    await this.crowdsale.finalize({ from: owner }).should.be.rejectedWith(EVMRevert)
-  })
+    await this.crowdsale.finalize({ from: owner }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('cannot be finalized by third party after ending', async function () {
-    await increaseTimeTo(this.afterEndTime)
-    await this.crowdsale.finalize({ from: thirdparty }).should.be.rejectedWith(EVMRevert)
-  })
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.finalize({ from: thirdparty }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('can be finalized by owner after ending', async function () {
-    await increaseTimeTo(this.afterEndTime)
-    await this.crowdsale.finalize({ from: owner }).should.be.fulfilled
-  })
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.finalize({ from: owner }).should.be.fulfilled;
+  });
 
   it('cannot be finalized twice', async function () {
-    await increaseTimeTo(this.afterEndTime)
-    await this.crowdsale.finalize({ from: owner })
-    await this.crowdsale.finalize({ from: owner }).should.be.rejectedWith(EVMRevert)
-  })
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.finalize({ from: owner });
+    await this.crowdsale.finalize({ from: owner }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('logs finalized', async function () {
-    await increaseTimeTo(this.afterEndTime)
-    const { logs } = await this.crowdsale.finalize({ from: owner })
-    const event = logs.find(e => e.event === 'Finalized')
-    should.exist(event)
-  })
-})
+    await increaseTimeTo(this.afterEndTime);
+    const { logs } = await this.crowdsale.finalize({ from: owner });
+    const event = logs.find(e => e.event === 'Finalized');
+    should.exist(event);
+  });
+});
diff --git a/test/HasNoContracts.test.js b/test/HasNoContracts.test.js
index f8d435a5660..e2743731f99 100644
--- a/test/HasNoContracts.test.js
+++ b/test/HasNoContracts.test.js
@@ -1,35 +1,35 @@
 
-import expectThrow from './helpers/expectThrow'
+import expectThrow from './helpers/expectThrow';
 
-const Ownable = artifacts.require('../contracts/ownership/Ownable.sol')
+const Ownable = artifacts.require('../contracts/ownership/Ownable.sol');
 const HasNoContracts = artifacts.require(
   '../contracts/ownership/HasNoContracts.sol',
-)
+);
 
 contract('HasNoContracts', function (accounts) {
-  let hasNoContracts = null
-  let ownable = null
+  let hasNoContracts = null;
+  let ownable = null;
 
   beforeEach(async () => {
     // Create contract and token
-    hasNoContracts = await HasNoContracts.new()
-    ownable = await Ownable.new()
+    hasNoContracts = await HasNoContracts.new();
+    ownable = await Ownable.new();
 
     // Force ownership into contract
-    await ownable.transferOwnership(hasNoContracts.address)
-    const owner = await ownable.owner()
-    assert.equal(owner, hasNoContracts.address)
-  })
+    await ownable.transferOwnership(hasNoContracts.address);
+    const owner = await ownable.owner();
+    assert.equal(owner, hasNoContracts.address);
+  });
 
   it('should allow owner to reclaim contracts', async function () {
-    await hasNoContracts.reclaimContract(ownable.address)
-    const owner = await ownable.owner()
-    assert.equal(owner, accounts[0])
-  })
+    await hasNoContracts.reclaimContract(ownable.address);
+    const owner = await ownable.owner();
+    assert.equal(owner, accounts[0]);
+  });
 
   it('should allow only owner to reclaim contracts', async function () {
     await expectThrow(
       hasNoContracts.reclaimContract(ownable.address, { from: accounts[1] }),
-    )
-  })
-})
+    );
+  });
+});
diff --git a/test/HasNoEther.test.js b/test/HasNoEther.test.js
index 5b9eebf96eb..e7ec486a1dd 100644
--- a/test/HasNoEther.test.js
+++ b/test/HasNoEther.test.js
@@ -1,22 +1,22 @@
 
-import expectThrow from './helpers/expectThrow'
-import toPromise from './helpers/toPromise'
-const HasNoEtherTest = artifacts.require('../mocks/HasNoEtherTest.sol')
-const ForceEther = artifacts.require('../mocks/ForceEther.sol')
+import expectThrow from './helpers/expectThrow';
+import toPromise from './helpers/toPromise';
+const HasNoEtherTest = artifacts.require('../mocks/HasNoEtherTest.sol');
+const ForceEther = artifacts.require('../mocks/ForceEther.sol');
 
 contract('HasNoEther', function (accounts) {
-  const amount = web3.toWei('1', 'ether')
+  const amount = web3.toWei('1', 'ether');
 
   it('should be constructorable', async function () {
-    await HasNoEtherTest.new()
-  })
+    await HasNoEtherTest.new();
+  });
 
   it('should not accept ether in constructor', async function () {
-    await expectThrow(HasNoEtherTest.new({ value: amount }))
-  })
+    await expectThrow(HasNoEtherTest.new({ value: amount }));
+  });
 
   it('should not accept ether', async function () {
-    let hasNoEther = await HasNoEtherTest.new()
+    let hasNoEther = await HasNoEtherTest.new();
 
     await expectThrow(
       toPromise(web3.eth.sendTransaction)({
@@ -24,41 +24,41 @@ contract('HasNoEther', function (accounts) {
         to: hasNoEther.address,
         value: amount,
       }),
-    )
-  })
+    );
+  });
 
   it('should allow owner to reclaim ether', async function () {
     // Create contract
-    let hasNoEther = await HasNoEtherTest.new()
-    const startBalance = await web3.eth.getBalance(hasNoEther.address)
-    assert.equal(startBalance, 0)
+    let hasNoEther = await HasNoEtherTest.new();
+    const startBalance = await web3.eth.getBalance(hasNoEther.address);
+    assert.equal(startBalance, 0);
 
     // Force ether into it
-    let forceEther = await ForceEther.new({ value: amount })
-    await forceEther.destroyAndSend(hasNoEther.address)
-    const forcedBalance = await web3.eth.getBalance(hasNoEther.address)
-    assert.equal(forcedBalance, amount)
+    let forceEther = await ForceEther.new({ value: amount });
+    await forceEther.destroyAndSend(hasNoEther.address);
+    const forcedBalance = await web3.eth.getBalance(hasNoEther.address);
+    assert.equal(forcedBalance, amount);
 
     // Reclaim
-    const ownerStartBalance = await web3.eth.getBalance(accounts[0])
-    await hasNoEther.reclaimEther()
-    const ownerFinalBalance = await web3.eth.getBalance(accounts[0])
-    const finalBalance = await web3.eth.getBalance(hasNoEther.address)
-    assert.equal(finalBalance, 0)
-    assert.isAbove(ownerFinalBalance, ownerStartBalance)
-  })
+    const ownerStartBalance = await web3.eth.getBalance(accounts[0]);
+    await hasNoEther.reclaimEther();
+    const ownerFinalBalance = await web3.eth.getBalance(accounts[0]);
+    const finalBalance = await web3.eth.getBalance(hasNoEther.address);
+    assert.equal(finalBalance, 0);
+    assert.isAbove(ownerFinalBalance, ownerStartBalance);
+  });
 
   it('should allow only owner to reclaim ether', async function () {
     // Create contract
-    let hasNoEther = await HasNoEtherTest.new({ from: accounts[0] })
+    let hasNoEther = await HasNoEtherTest.new({ from: accounts[0] });
 
     // Force ether into it
-    let forceEther = await ForceEther.new({ value: amount })
-    await forceEther.destroyAndSend(hasNoEther.address)
-    const forcedBalance = await web3.eth.getBalance(hasNoEther.address)
-    assert.equal(forcedBalance, amount)
+    let forceEther = await ForceEther.new({ value: amount });
+    await forceEther.destroyAndSend(hasNoEther.address);
+    const forcedBalance = await web3.eth.getBalance(hasNoEther.address);
+    assert.equal(forcedBalance, amount);
 
     // Reclaim
-    await expectThrow(hasNoEther.reclaimEther({ from: accounts[1] }))
-  })
-})
+    await expectThrow(hasNoEther.reclaimEther({ from: accounts[1] }));
+  });
+});
diff --git a/test/HasNoTokens.test.js b/test/HasNoTokens.test.js
index dc85788ae94..cb397deea56 100644
--- a/test/HasNoTokens.test.js
+++ b/test/HasNoTokens.test.js
@@ -1,40 +1,40 @@
 
-import expectThrow from './helpers/expectThrow'
+import expectThrow from './helpers/expectThrow';
 
-const HasNoTokens = artifacts.require('../contracts/lifecycle/HasNoTokens.sol')
-const ERC23TokenMock = artifacts.require('./mocks/ERC23TokenMock.sol')
+const HasNoTokens = artifacts.require('../contracts/lifecycle/HasNoTokens.sol');
+const ERC23TokenMock = artifacts.require('./mocks/ERC23TokenMock.sol');
 
 contract('HasNoTokens', function (accounts) {
-  let hasNoTokens = null
-  let token = null
+  let hasNoTokens = null;
+  let token = null;
 
   beforeEach(async () => {
     // Create contract and token
-    hasNoTokens = await HasNoTokens.new()
-    token = await ERC23TokenMock.new(accounts[0], 100)
+    hasNoTokens = await HasNoTokens.new();
+    token = await ERC23TokenMock.new(accounts[0], 100);
 
     // Force token into contract
-    await token.transfer(hasNoTokens.address, 10)
-    const startBalance = await token.balanceOf(hasNoTokens.address)
-    assert.equal(startBalance, 10)
-  })
+    await token.transfer(hasNoTokens.address, 10);
+    const startBalance = await token.balanceOf(hasNoTokens.address);
+    assert.equal(startBalance, 10);
+  });
 
   it('should not accept ERC23 tokens', async function () {
-    await expectThrow(token.transferERC23(hasNoTokens.address, 10, ''))
-  })
+    await expectThrow(token.transferERC23(hasNoTokens.address, 10, ''));
+  });
 
   it('should allow owner to reclaim tokens', async function () {
-    const ownerStartBalance = await token.balanceOf(accounts[0])
-    await hasNoTokens.reclaimToken(token.address)
-    const ownerFinalBalance = await token.balanceOf(accounts[0])
-    const finalBalance = await token.balanceOf(hasNoTokens.address)
-    assert.equal(finalBalance, 0)
-    assert.equal(ownerFinalBalance - ownerStartBalance, 10)
-  })
+    const ownerStartBalance = await token.balanceOf(accounts[0]);
+    await hasNoTokens.reclaimToken(token.address);
+    const ownerFinalBalance = await token.balanceOf(accounts[0]);
+    const finalBalance = await token.balanceOf(hasNoTokens.address);
+    assert.equal(finalBalance, 0);
+    assert.equal(ownerFinalBalance - ownerStartBalance, 10);
+  });
 
   it('should allow only owner to reclaim tokens', async function () {
     await expectThrow(
       hasNoTokens.reclaimToken(token.address, { from: accounts[1] }),
-    )
-  })
-})
+    );
+  });
+});
diff --git a/test/LimitBalance.test.js b/test/LimitBalance.test.js
index b9534630f6c..bebab9f98aa 100644
--- a/test/LimitBalance.test.js
+++ b/test/LimitBalance.test.js
@@ -1,59 +1,59 @@
 
-var LimitBalanceMock = artifacts.require('mocks/LimitBalanceMock.sol')
-const assertRevert = require('./helpers/assertRevert')
+var LimitBalanceMock = artifacts.require('mocks/LimitBalanceMock.sol');
+const assertRevert = require('./helpers/assertRevert');
 
 contract('LimitBalance', function (accounts) {
-  let lb
+  let lb;
 
   beforeEach(async function () {
-    lb = await LimitBalanceMock.new()
-  })
+    lb = await LimitBalanceMock.new();
+  });
 
-  let LIMIT = 1000
+  let LIMIT = 1000;
 
   it('should expose limit', async function () {
-    let limit = await lb.limit()
-    assert.equal(limit, LIMIT)
-  })
+    let limit = await lb.limit();
+    assert.equal(limit, LIMIT);
+  });
 
   it('should allow sending below limit', async function () {
-    let amount = 1
-    await lb.limitedDeposit({ value: amount })
+    let amount = 1;
+    await lb.limitedDeposit({ value: amount });
 
-    assert.equal(web3.eth.getBalance(lb.address), amount)
-  })
+    assert.equal(web3.eth.getBalance(lb.address), amount);
+  });
 
   it('shouldnt allow sending above limit', async function () {
-    let amount = 1110
+    let amount = 1110;
     try {
-      await lb.limitedDeposit({ value: amount })
-      assert.fail('should have thrown before')
+      await lb.limitedDeposit({ value: amount });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should allow multiple sends below limit', async function () {
-    let amount = 500
-    await lb.limitedDeposit({ value: amount })
+    let amount = 500;
+    await lb.limitedDeposit({ value: amount });
 
-    assert.equal(web3.eth.getBalance(lb.address), amount)
+    assert.equal(web3.eth.getBalance(lb.address), amount);
 
-    await lb.limitedDeposit({ value: amount })
-    assert.equal(web3.eth.getBalance(lb.address), amount * 2)
-  })
+    await lb.limitedDeposit({ value: amount });
+    assert.equal(web3.eth.getBalance(lb.address), amount * 2);
+  });
 
   it('shouldnt allow multiple sends above limit', async function () {
-    let amount = 500
-    await lb.limitedDeposit({ value: amount })
+    let amount = 500;
+    await lb.limitedDeposit({ value: amount });
 
-    assert.equal(web3.eth.getBalance(lb.address), amount)
+    assert.equal(web3.eth.getBalance(lb.address), amount);
 
     try {
-      await lb.limitedDeposit({ value: amount + 1 })
-      assert.fail('should have thrown before')
+      await lb.limitedDeposit({ value: amount + 1 });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/MerkleProof.test.js b/test/MerkleProof.test.js
index fd4a91aba99..f55d6ebc8b5 100644
--- a/test/MerkleProof.test.js
+++ b/test/MerkleProof.test.js
@@ -1,61 +1,61 @@
 
-import MerkleTree from './helpers/merkleTree.js'
-import { sha3, bufferToHex } from 'ethereumjs-util'
+import MerkleTree from './helpers/merkleTree.js';
+import { sha3, bufferToHex } from 'ethereumjs-util';
 
-var MerkleProof = artifacts.require('./MerkleProof.sol')
+var MerkleProof = artifacts.require('./MerkleProof.sol');
 
 contract('MerkleProof', function (accounts) {
-  let merkleProof
+  let merkleProof;
 
   before(async function () {
-    merkleProof = await MerkleProof.new()
-  })
+    merkleProof = await MerkleProof.new();
+  });
 
   describe('verifyProof', function () {
     it('should return true for a valid Merkle proof', async function () {
-      const elements = ['a', 'b', 'c', 'd']
-      const merkleTree = new MerkleTree(elements)
+      const elements = ['a', 'b', 'c', 'd'];
+      const merkleTree = new MerkleTree(elements);
 
-      const root = merkleTree.getHexRoot()
+      const root = merkleTree.getHexRoot();
 
-      const proof = merkleTree.getHexProof(elements[0])
+      const proof = merkleTree.getHexProof(elements[0]);
 
-      const leaf = bufferToHex(sha3(elements[0]))
+      const leaf = bufferToHex(sha3(elements[0]));
 
-      const result = await merkleProof.verifyProof(proof, root, leaf)
-      assert.isOk(result, 'verifyProof did not return true for a valid proof')
-    })
+      const result = await merkleProof.verifyProof(proof, root, leaf);
+      assert.isOk(result, 'verifyProof did not return true for a valid proof');
+    });
 
     it('should return false for an invalid Merkle proof', async function () {
-      const correctElements = ['a', 'b', 'c']
-      const correctMerkleTree = new MerkleTree(correctElements)
+      const correctElements = ['a', 'b', 'c'];
+      const correctMerkleTree = new MerkleTree(correctElements);
 
-      const correctRoot = correctMerkleTree.getHexRoot()
+      const correctRoot = correctMerkleTree.getHexRoot();
 
-      const correctLeaf = bufferToHex(sha3(correctElements[0]))
+      const correctLeaf = bufferToHex(sha3(correctElements[0]));
 
-      const badElements = ['d', 'e', 'f']
-      const badMerkleTree = new MerkleTree(badElements)
+      const badElements = ['d', 'e', 'f'];
+      const badMerkleTree = new MerkleTree(badElements);
 
-      const badProof = badMerkleTree.getHexProof(badElements[0])
+      const badProof = badMerkleTree.getHexProof(badElements[0]);
 
-      const result = await merkleProof.verifyProof(badProof, correctRoot, correctLeaf)
-      assert.isNotOk(result, 'verifyProof did not return false for an invalid proof')
-    })
+      const result = await merkleProof.verifyProof(badProof, correctRoot, correctLeaf);
+      assert.isNotOk(result, 'verifyProof did not return false for an invalid proof');
+    });
 
     it('should return false for a Merkle proof of invalid length', async function () {
-      const elements = ['a', 'b', 'c']
-      const merkleTree = new MerkleTree(elements)
+      const elements = ['a', 'b', 'c'];
+      const merkleTree = new MerkleTree(elements);
 
-      const root = merkleTree.getHexRoot()
+      const root = merkleTree.getHexRoot();
 
-      const proof = merkleTree.getHexProof(elements[0])
-      const badProof = proof.slice(0, proof.length - 5)
+      const proof = merkleTree.getHexProof(elements[0]);
+      const badProof = proof.slice(0, proof.length - 5);
 
-      const leaf = bufferToHex(sha3(elements[0]))
+      const leaf = bufferToHex(sha3(elements[0]));
 
-      const result = await merkleProof.verifyProof(badProof, root, leaf)
-      assert.isNotOk(result, 'verifyProof did not return false for proof of invalid length')
-    })
-  })
-})
+      const result = await merkleProof.verifyProof(badProof, root, leaf);
+      assert.isNotOk(result, 'verifyProof did not return false for proof of invalid length');
+    });
+  });
+});
diff --git a/test/MintableToken.test.js b/test/MintableToken.test.js
index 1bde229b796..ba287a3672e 100644
--- a/test/MintableToken.test.js
+++ b/test/MintableToken.test.js
@@ -1,44 +1,44 @@
 
-import expectThrow from './helpers/expectThrow'
-var MintableToken = artifacts.require('../contracts/Tokens/MintableToken.sol')
+import expectThrow from './helpers/expectThrow';
+var MintableToken = artifacts.require('../contracts/Tokens/MintableToken.sol');
 
 contract('Mintable', function (accounts) {
-  let token
+  let token;
 
   beforeEach(async function () {
-    token = await MintableToken.new()
-  })
+    token = await MintableToken.new();
+  });
 
   it('should start with a totalSupply of 0', async function () {
-    let totalSupply = await token.totalSupply()
+    let totalSupply = await token.totalSupply();
 
-    assert.equal(totalSupply, 0)
-  })
+    assert.equal(totalSupply, 0);
+  });
 
   it('should return mintingFinished false after construction', async function () {
-    let mintingFinished = await token.mintingFinished()
+    let mintingFinished = await token.mintingFinished();
 
-    assert.equal(mintingFinished, false)
-  })
+    assert.equal(mintingFinished, false);
+  });
 
   it('should mint a given amount of tokens to a given address', async function () {
-    const result = await token.mint(accounts[0], 100)
-    assert.equal(result.logs[0].event, 'Mint')
-    assert.equal(result.logs[0].args.to.valueOf(), accounts[0])
-    assert.equal(result.logs[0].args.amount.valueOf(), 100)
-    assert.equal(result.logs[1].event, 'Transfer')
-    assert.equal(result.logs[1].args.from.valueOf(), 0x0)
+    const result = await token.mint(accounts[0], 100);
+    assert.equal(result.logs[0].event, 'Mint');
+    assert.equal(result.logs[0].args.to.valueOf(), accounts[0]);
+    assert.equal(result.logs[0].args.amount.valueOf(), 100);
+    assert.equal(result.logs[1].event, 'Transfer');
+    assert.equal(result.logs[1].args.from.valueOf(), 0x0);
 
-    let balance0 = await token.balanceOf(accounts[0])
-    assert(balance0, 100)
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert(balance0, 100);
 
-    let totalSupply = await token.totalSupply()
-    assert(totalSupply, 100)
-  })
+    let totalSupply = await token.totalSupply();
+    assert(totalSupply, 100);
+  });
 
   it('should fail to mint after call to finishMinting', async function () {
-    await token.finishMinting()
-    assert.equal(await token.mintingFinished(), true)
-    await expectThrow(token.mint(accounts[0], 100))
-  })
-})
+    await token.finishMinting();
+    assert.equal(await token.mintingFinished(), true);
+    await expectThrow(token.mint(accounts[0], 100));
+  });
+});
diff --git a/test/Ownable.test.js b/test/Ownable.test.js
index 6904d8325a8..e1920602ef5 100644
--- a/test/Ownable.test.js
+++ b/test/Ownable.test.js
@@ -1,47 +1,47 @@
 
-const assertRevert = require('./helpers/assertRevert')
+const assertRevert = require('./helpers/assertRevert');
 
-var Ownable = artifacts.require('../contracts/ownership/Ownable.sol')
+var Ownable = artifacts.require('../contracts/ownership/Ownable.sol');
 
 contract('Ownable', function (accounts) {
-  let ownable
+  let ownable;
 
   beforeEach(async function () {
-    ownable = await Ownable.new()
-  })
+    ownable = await Ownable.new();
+  });
 
   it('should have an owner', async function () {
-    let owner = await ownable.owner()
-    assert.isTrue(owner !== 0)
-  })
+    let owner = await ownable.owner();
+    assert.isTrue(owner !== 0);
+  });
 
   it('changes owner after transfer', async function () {
-    let other = accounts[1]
-    await ownable.transferOwnership(other)
-    let owner = await ownable.owner()
+    let other = accounts[1];
+    await ownable.transferOwnership(other);
+    let owner = await ownable.owner();
 
-    assert.isTrue(owner === other)
-  })
+    assert.isTrue(owner === other);
+  });
 
   it('should prevent non-owners from transfering', async function () {
-    const other = accounts[2]
-    const owner = await ownable.owner.call()
-    assert.isTrue(owner !== other)
+    const other = accounts[2];
+    const owner = await ownable.owner.call();
+    assert.isTrue(owner !== other);
     try {
-      await ownable.transferOwnership(other, { from: other })
-      assert.fail('should have thrown before')
+      await ownable.transferOwnership(other, { from: other });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should guard ownership against stuck state', async function () {
-    let originalOwner = await ownable.owner()
+    let originalOwner = await ownable.owner();
     try {
-      await ownable.transferOwnership(null, { from: originalOwner })
-      assert.fail()
+      await ownable.transferOwnership(null, { from: originalOwner });
+      assert.fail();
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/Pausable.test.js b/test/Pausable.test.js
index 467c3a2ce01..d061a8fe295 100644
--- a/test/Pausable.test.js
+++ b/test/Pausable.test.js
@@ -1,77 +1,77 @@
 
-const assertRevert = require('./helpers/assertRevert')
-const PausableMock = artifacts.require('mocks/PausableMock.sol')
+const assertRevert = require('./helpers/assertRevert');
+const PausableMock = artifacts.require('mocks/PausableMock.sol');
 
 contract('Pausable', function (accounts) {
   it('can perform normal process in non-pause', async function () {
-    let Pausable = await PausableMock.new()
-    let count0 = await Pausable.count()
-    assert.equal(count0, 0)
+    let Pausable = await PausableMock.new();
+    let count0 = await Pausable.count();
+    assert.equal(count0, 0);
 
-    await Pausable.normalProcess()
-    let count1 = await Pausable.count()
-    assert.equal(count1, 1)
-  })
+    await Pausable.normalProcess();
+    let count1 = await Pausable.count();
+    assert.equal(count1, 1);
+  });
 
   it('can not perform normal process in pause', async function () {
-    let Pausable = await PausableMock.new()
-    await Pausable.pause()
-    let count0 = await Pausable.count()
-    assert.equal(count0, 0)
+    let Pausable = await PausableMock.new();
+    await Pausable.pause();
+    let count0 = await Pausable.count();
+    assert.equal(count0, 0);
 
     try {
-      await Pausable.normalProcess()
-      assert.fail('should have thrown before')
+      await Pausable.normalProcess();
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-    let count1 = await Pausable.count()
-    assert.equal(count1, 0)
-  })
+    let count1 = await Pausable.count();
+    assert.equal(count1, 0);
+  });
 
   it('can not take drastic measure in non-pause', async function () {
-    let Pausable = await PausableMock.new()
+    let Pausable = await PausableMock.new();
     try {
-      await Pausable.drasticMeasure()
-      assert.fail('should have thrown before')
+      await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-    const drasticMeasureTaken = await Pausable.drasticMeasureTaken()
-    assert.isFalse(drasticMeasureTaken)
-  })
+    const drasticMeasureTaken = await Pausable.drasticMeasureTaken();
+    assert.isFalse(drasticMeasureTaken);
+  });
 
   it('can take a drastic measure in a pause', async function () {
-    let Pausable = await PausableMock.new()
-    await Pausable.pause()
-    await Pausable.drasticMeasure()
-    let drasticMeasureTaken = await Pausable.drasticMeasureTaken()
+    let Pausable = await PausableMock.new();
+    await Pausable.pause();
+    await Pausable.drasticMeasure();
+    let drasticMeasureTaken = await Pausable.drasticMeasureTaken();
 
-    assert.isTrue(drasticMeasureTaken)
-  })
+    assert.isTrue(drasticMeasureTaken);
+  });
 
   it('should resume allowing normal process after pause is over', async function () {
-    let Pausable = await PausableMock.new()
-    await Pausable.pause()
-    await Pausable.unpause()
-    await Pausable.normalProcess()
-    let count0 = await Pausable.count()
+    let Pausable = await PausableMock.new();
+    await Pausable.pause();
+    await Pausable.unpause();
+    await Pausable.normalProcess();
+    let count0 = await Pausable.count();
 
-    assert.equal(count0, 1)
-  })
+    assert.equal(count0, 1);
+  });
 
   it('should prevent drastic measure after pause is over', async function () {
-    let Pausable = await PausableMock.new()
-    await Pausable.pause()
-    await Pausable.unpause()
+    let Pausable = await PausableMock.new();
+    await Pausable.pause();
+    await Pausable.unpause();
     try {
-      await Pausable.drasticMeasure()
-      assert.fail('should have thrown before')
+      await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
 
-    const drasticMeasureTaken = await Pausable.drasticMeasureTaken()
-    assert.isFalse(drasticMeasureTaken)
-  })
-})
+    const drasticMeasureTaken = await Pausable.drasticMeasureTaken();
+    assert.isFalse(drasticMeasureTaken);
+  });
+});
diff --git a/test/PausableToken.test.js b/test/PausableToken.test.js
index 99bdb0d1839..dc9cb826f0a 100644
--- a/test/PausableToken.test.js
+++ b/test/PausableToken.test.js
@@ -1,73 +1,73 @@
-'user strict'
+'user strict';
 
-const assertRevert = require('./helpers/assertRevert')
-var PausableTokenMock = artifacts.require('./mocks/PausableTokenMock.sol')
+const assertRevert = require('./helpers/assertRevert');
+var PausableTokenMock = artifacts.require('./mocks/PausableTokenMock.sol');
 
 contract('PausableToken', function (accounts) {
-  let token
+  let token;
 
   beforeEach(async function () {
-    token = await PausableTokenMock.new(accounts[0], 100)
-  })
+    token = await PausableTokenMock.new(accounts[0], 100);
+  });
 
   it('should return paused false after construction', async function () {
-    let paused = await token.paused()
+    let paused = await token.paused();
 
-    assert.equal(paused, false)
-  })
+    assert.equal(paused, false);
+  });
 
   it('should return paused true after pause', async function () {
-    await token.pause()
-    let paused = await token.paused()
+    await token.pause();
+    let paused = await token.paused();
 
-    assert.equal(paused, true)
-  })
+    assert.equal(paused, true);
+  });
 
   it('should return paused false after pause and unpause', async function () {
-    await token.pause()
-    await token.unpause()
-    let paused = await token.paused()
+    await token.pause();
+    await token.unpause();
+    let paused = await token.paused();
 
-    assert.equal(paused, false)
-  })
+    assert.equal(paused, false);
+  });
 
   it('should be able to transfer if transfers are unpaused', async function () {
-    await token.transfer(accounts[1], 100)
-    let balance0 = await token.balanceOf(accounts[0])
-    assert.equal(balance0, 0)
+    await token.transfer(accounts[1], 100);
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
 
-    let balance1 = await token.balanceOf(accounts[1])
-    assert.equal(balance1, 100)
-  })
+    let balance1 = await token.balanceOf(accounts[1]);
+    assert.equal(balance1, 100);
+  });
 
   it('should be able to transfer after transfers are paused and unpaused', async function () {
-    await token.pause()
-    await token.unpause()
-    await token.transfer(accounts[1], 100)
-    let balance0 = await token.balanceOf(accounts[0])
-    assert.equal(balance0, 0)
+    await token.pause();
+    await token.unpause();
+    await token.transfer(accounts[1], 100);
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
 
-    let balance1 = await token.balanceOf(accounts[1])
-    assert.equal(balance1, 100)
-  })
+    let balance1 = await token.balanceOf(accounts[1]);
+    assert.equal(balance1, 100);
+  });
 
   it('should throw an error trying to transfer while transactions are paused', async function () {
-    await token.pause()
+    await token.pause();
     try {
-      await token.transfer(accounts[1], 100)
-      assert.fail('should have thrown before')
+      await token.transfer(accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should throw an error trying to transfer from another account while transactions are paused', async function () {
-    await token.pause()
+    await token.pause();
     try {
-      await token.transferFrom(accounts[0], accounts[1], 100)
-      assert.fail('should have thrown before')
+      await token.transferFrom(accounts[0], accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/PullPayment.test.js b/test/PullPayment.test.js
index 5c37e8e9189..176b182dd4d 100644
--- a/test/PullPayment.test.js
+++ b/test/PullPayment.test.js
@@ -1,71 +1,71 @@
-var PullPaymentMock = artifacts.require('./mocks/PullPaymentMock.sol')
+var PullPaymentMock = artifacts.require('./mocks/PullPaymentMock.sol');
 
 contract('PullPayment', function (accounts) {
-  let ppce
-  let amount = 17 * 1e18
+  let ppce;
+  let amount = 17 * 1e18;
 
   beforeEach(async function () {
-    ppce = await PullPaymentMock.new({ value: amount })
-  })
+    ppce = await PullPaymentMock.new({ value: amount });
+  });
 
   it('can\'t call asyncSend externally', async function () {
-    assert.isUndefined(ppce.asyncSend)
-  })
+    assert.isUndefined(ppce.asyncSend);
+  });
 
   it('can record an async payment correctly', async function () {
-    let AMOUNT = 100
-    await ppce.callSend(accounts[0], AMOUNT)
-    let paymentsToAccount0 = await ppce.payments(accounts[0])
-    let totalPayments = await ppce.totalPayments()
+    let AMOUNT = 100;
+    await ppce.callSend(accounts[0], AMOUNT);
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+    let totalPayments = await ppce.totalPayments();
 
-    assert.equal(totalPayments, AMOUNT)
-    assert.equal(paymentsToAccount0, AMOUNT)
-  })
+    assert.equal(totalPayments, AMOUNT);
+    assert.equal(paymentsToAccount0, AMOUNT);
+  });
 
   it('can add multiple balances on one account', async function () {
-    await ppce.callSend(accounts[0], 200)
-    await ppce.callSend(accounts[0], 300)
-    let paymentsToAccount0 = await ppce.payments(accounts[0])
-    let totalPayments = await ppce.totalPayments()
+    await ppce.callSend(accounts[0], 200);
+    await ppce.callSend(accounts[0], 300);
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+    let totalPayments = await ppce.totalPayments();
 
-    assert.equal(totalPayments, 500)
-    assert.equal(paymentsToAccount0, 500)
-  })
+    assert.equal(totalPayments, 500);
+    assert.equal(paymentsToAccount0, 500);
+  });
 
   it('can add balances on multiple accounts', async function () {
-    await ppce.callSend(accounts[0], 200)
-    await ppce.callSend(accounts[1], 300)
+    await ppce.callSend(accounts[0], 200);
+    await ppce.callSend(accounts[1], 300);
 
-    let paymentsToAccount0 = await ppce.payments(accounts[0])
-    assert.equal(paymentsToAccount0, 200)
+    let paymentsToAccount0 = await ppce.payments(accounts[0]);
+    assert.equal(paymentsToAccount0, 200);
 
-    let paymentsToAccount1 = await ppce.payments(accounts[1])
-    assert.equal(paymentsToAccount1, 300)
+    let paymentsToAccount1 = await ppce.payments(accounts[1]);
+    assert.equal(paymentsToAccount1, 300);
 
-    let totalPayments = await ppce.totalPayments()
-    assert.equal(totalPayments, 500)
-  })
+    let totalPayments = await ppce.totalPayments();
+    assert.equal(totalPayments, 500);
+  });
 
   it('can withdraw payment', async function () {
-    let payee = accounts[1]
-    let initialBalance = web3.eth.getBalance(payee)
+    let payee = accounts[1];
+    let initialBalance = web3.eth.getBalance(payee);
 
-    await ppce.callSend(payee, amount)
+    await ppce.callSend(payee, amount);
 
-    let payment1 = await ppce.payments(payee)
-    assert.equal(payment1, amount)
+    let payment1 = await ppce.payments(payee);
+    assert.equal(payment1, amount);
 
-    let totalPayments = await ppce.totalPayments()
-    assert.equal(totalPayments, amount)
+    let totalPayments = await ppce.totalPayments();
+    assert.equal(totalPayments, amount);
 
-    await ppce.withdrawPayments({ from: payee })
-    let payment2 = await ppce.payments(payee)
-    assert.equal(payment2, 0)
+    await ppce.withdrawPayments({ from: payee });
+    let payment2 = await ppce.payments(payee);
+    assert.equal(payment2, 0);
 
-    totalPayments = await ppce.totalPayments()
-    assert.equal(totalPayments, 0)
+    totalPayments = await ppce.totalPayments();
+    assert.equal(totalPayments, 0);
 
-    let balance = web3.eth.getBalance(payee)
-    assert(Math.abs(balance - initialBalance - amount) < 1e16)
-  })
-})
+    let balance = web3.eth.getBalance(payee);
+    assert(Math.abs(balance - initialBalance - amount) < 1e16);
+  });
+});
diff --git a/test/ReentrancyGuard.test.js b/test/ReentrancyGuard.test.js
index 0c7568a2cf0..ae1446c9a33 100644
--- a/test/ReentrancyGuard.test.js
+++ b/test/ReentrancyGuard.test.js
@@ -1,31 +1,31 @@
 
-import expectThrow from './helpers/expectThrow'
-const ReentrancyMock = artifacts.require('./helper/ReentrancyMock.sol')
-const ReentrancyAttack = artifacts.require('./helper/ReentrancyAttack.sol')
+import expectThrow from './helpers/expectThrow';
+const ReentrancyMock = artifacts.require('./helper/ReentrancyMock.sol');
+const ReentrancyAttack = artifacts.require('./helper/ReentrancyAttack.sol');
 
 contract('ReentrancyGuard', function (accounts) {
-  let reentrancyMock
+  let reentrancyMock;
 
   beforeEach(async function () {
-    reentrancyMock = await ReentrancyMock.new()
-    let initialCounter = await reentrancyMock.counter()
-    assert.equal(initialCounter, 0)
-  })
+    reentrancyMock = await ReentrancyMock.new();
+    let initialCounter = await reentrancyMock.counter();
+    assert.equal(initialCounter, 0);
+  });
 
   it('should not allow remote callback', async function () {
-    let attacker = await ReentrancyAttack.new()
-    await expectThrow(reentrancyMock.countAndCall(attacker.address))
-  })
+    let attacker = await ReentrancyAttack.new();
+    await expectThrow(reentrancyMock.countAndCall(attacker.address));
+  });
 
   // The following are more side-effects that intended behaviour:
   // I put them here as documentation, and to monitor any changes
   // in the side-effects.
 
   it('should not allow local recursion', async function () {
-    await expectThrow(reentrancyMock.countLocalRecursive(10))
-  })
+    await expectThrow(reentrancyMock.countLocalRecursive(10));
+  });
 
   it('should not allow indirect local recursion', async function () {
-    await expectThrow(reentrancyMock.countThisRecursive(10))
-  })
-})
+    await expectThrow(reentrancyMock.countThisRecursive(10));
+  });
+});
diff --git a/test/RefundVault.test.js b/test/RefundVault.test.js
index 4cfd0101f9f..0ce1dd74c68 100644
--- a/test/RefundVault.test.js
+++ b/test/RefundVault.test.js
@@ -1,59 +1,59 @@
-import ether from './helpers/ether'
-import EVMRevert from './helpers/EVMRevert'
+import ether from './helpers/ether';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const RefundVault = artifacts.require('RefundVault')
+const RefundVault = artifacts.require('RefundVault');
 
 contract('RefundVault', function ([_, owner, wallet, investor]) {
-  const value = ether(42)
+  const value = ether(42);
 
   beforeEach(async function () {
-    this.vault = await RefundVault.new(wallet, { from: owner })
-  })
+    this.vault = await RefundVault.new(wallet, { from: owner });
+  });
 
   it('should accept contributions', async function () {
-    await this.vault.deposit(investor, { value, from: owner }).should.be.fulfilled
-  })
+    await this.vault.deposit(investor, { value, from: owner }).should.be.fulfilled;
+  });
 
   it('should not refund contribution during active state', async function () {
-    await this.vault.deposit(investor, { value, from: owner })
-    await this.vault.refund(investor).should.be.rejectedWith(EVMRevert)
-  })
+    await this.vault.deposit(investor, { value, from: owner });
+    await this.vault.refund(investor).should.be.rejectedWith(EVMRevert);
+  });
 
   it('only owner can enter refund mode', async function () {
-    await this.vault.enableRefunds({ from: _ }).should.be.rejectedWith(EVMRevert)
-    await this.vault.enableRefunds({ from: owner }).should.be.fulfilled
-  })
+    await this.vault.enableRefunds({ from: _ }).should.be.rejectedWith(EVMRevert);
+    await this.vault.enableRefunds({ from: owner }).should.be.fulfilled;
+  });
 
   it('should refund contribution after entering refund mode', async function () {
-    await this.vault.deposit(investor, { value, from: owner })
-    await this.vault.enableRefunds({ from: owner })
+    await this.vault.deposit(investor, { value, from: owner });
+    await this.vault.enableRefunds({ from: owner });
 
-    const pre = web3.eth.getBalance(investor)
-    await this.vault.refund(investor)
-    const post = web3.eth.getBalance(investor)
+    const pre = web3.eth.getBalance(investor);
+    await this.vault.refund(investor);
+    const post = web3.eth.getBalance(investor);
 
-    post.minus(pre).should.be.bignumber.equal(value)
-  })
+    post.minus(pre).should.be.bignumber.equal(value);
+  });
 
   it('only owner can close', async function () {
-    await this.vault.close({ from: _ }).should.be.rejectedWith(EVMRevert)
-    await this.vault.close({ from: owner }).should.be.fulfilled
-  })
+    await this.vault.close({ from: _ }).should.be.rejectedWith(EVMRevert);
+    await this.vault.close({ from: owner }).should.be.fulfilled;
+  });
 
   it('should forward funds to wallet after closing', async function () {
-    await this.vault.deposit(investor, { value, from: owner })
+    await this.vault.deposit(investor, { value, from: owner });
 
-    const pre = web3.eth.getBalance(wallet)
-    await this.vault.close({ from: owner })
-    const post = web3.eth.getBalance(wallet)
+    const pre = web3.eth.getBalance(wallet);
+    await this.vault.close({ from: owner });
+    const post = web3.eth.getBalance(wallet);
 
-    post.minus(pre).should.be.bignumber.equal(value)
-  })
-})
+    post.minus(pre).should.be.bignumber.equal(value);
+  });
+});
diff --git a/test/RefundableCrowdsale.test.js b/test/RefundableCrowdsale.test.js
index a73a8764bb1..84ced3bc7f1 100644
--- a/test/RefundableCrowdsale.test.js
+++ b/test/RefundableCrowdsale.test.js
@@ -1,80 +1,80 @@
-import ether from './helpers/ether'
-import { advanceBlock } from './helpers/advanceToBlock'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
-import latestTime from './helpers/latestTime'
-import EVMRevert from './helpers/EVMRevert'
+import ether from './helpers/ether';
+import { advanceBlock } from './helpers/advanceToBlock';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
+import latestTime from './helpers/latestTime';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const RefundableCrowdsale = artifacts.require('./mocks/RefundableCrowdsaleImpl.sol')
+const RefundableCrowdsale = artifacts.require('./mocks/RefundableCrowdsaleImpl.sol');
 
 contract('RefundableCrowdsale', function ([_, owner, wallet, investor]) {
-  const rate = new BigNumber(1000)
-  const goal = ether(800)
-  const lessThanGoal = ether(750)
+  const rate = new BigNumber(1000);
+  const goal = ether(800);
+  const lessThanGoal = ether(750);
 
   before(async function () {
     // Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
-    await advanceBlock()
-  })
+    await advanceBlock();
+  });
 
   beforeEach(async function () {
-    this.startTime = latestTime() + duration.weeks(1)
-    this.endTime = this.startTime + duration.weeks(1)
-    this.afterEndTime = this.endTime + duration.seconds(1)
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime = this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1);
 
-    this.crowdsale = await RefundableCrowdsale.new(this.startTime, this.endTime, rate, wallet, goal, { from: owner })
-  })
+    this.crowdsale = await RefundableCrowdsale.new(this.startTime, this.endTime, rate, wallet, goal, { from: owner });
+  });
 
   describe('creating a valid crowdsale', function () {
     it('should fail with zero goal', async function () {
       await RefundableCrowdsale.new(this.startTime, this.endTime, rate, wallet, 0, { from: owner })
-        .should.be.rejectedWith(EVMRevert)
-    })
-  })
+        .should.be.rejectedWith(EVMRevert);
+    });
+  });
 
   it('should deny refunds before end', async function () {
-    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert)
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert)
-  })
+    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert);
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should deny refunds after end if goal was reached', async function () {
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.sendTransaction({ value: goal, from: investor })
-    await increaseTimeTo(this.afterEndTime)
-    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert)
-  })
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.sendTransaction({ value: goal, from: investor });
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.claimRefund({ from: investor }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should allow refunds after end if goal was not reached', async function () {
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.sendTransaction({ value: lessThanGoal, from: investor })
-    await increaseTimeTo(this.afterEndTime)
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.sendTransaction({ value: lessThanGoal, from: investor });
+    await increaseTimeTo(this.afterEndTime);
 
-    await this.crowdsale.finalize({ from: owner })
+    await this.crowdsale.finalize({ from: owner });
 
-    const pre = web3.eth.getBalance(investor)
+    const pre = web3.eth.getBalance(investor);
     await this.crowdsale.claimRefund({ from: investor, gasPrice: 0 })
-      .should.be.fulfilled
-    const post = web3.eth.getBalance(investor)
+      .should.be.fulfilled;
+    const post = web3.eth.getBalance(investor);
 
-    post.minus(pre).should.be.bignumber.equal(lessThanGoal)
-  })
+    post.minus(pre).should.be.bignumber.equal(lessThanGoal);
+  });
 
   it('should forward funds to wallet after end if goal was reached', async function () {
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.sendTransaction({ value: goal, from: investor })
-    await increaseTimeTo(this.afterEndTime)
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.sendTransaction({ value: goal, from: investor });
+    await increaseTimeTo(this.afterEndTime);
 
-    const pre = web3.eth.getBalance(wallet)
-    await this.crowdsale.finalize({ from: owner })
-    const post = web3.eth.getBalance(wallet)
+    const pre = web3.eth.getBalance(wallet);
+    await this.crowdsale.finalize({ from: owner });
+    const post = web3.eth.getBalance(wallet);
 
-    post.minus(pre).should.be.bignumber.equal(goal)
-  })
-})
+    post.minus(pre).should.be.bignumber.equal(goal);
+  });
+});
diff --git a/test/SafeERC20.test.js b/test/SafeERC20.test.js
index f342cb52f25..9b93521d0e0 100644
--- a/test/SafeERC20.test.js
+++ b/test/SafeERC20.test.js
@@ -1,37 +1,37 @@
-import EVMThrow from './helpers/EVMThrow'
+import EVMThrow from './helpers/EVMThrow';
 
 require('chai')
   .use(require('chai-as-promised'))
-  .should()
+  .should();
 
-const SafeERC20Helper = artifacts.require('./mocks/SafeERC20Helper.sol')
+const SafeERC20Helper = artifacts.require('./mocks/SafeERC20Helper.sol');
 
 contract('SafeERC20', function () {
   beforeEach(async function () {
-    this.helper = await SafeERC20Helper.new()
-  })
+    this.helper = await SafeERC20Helper.new();
+  });
 
   it('should throw on failed transfer', async function () {
-    await this.helper.doFailingTransfer().should.be.rejectedWith(EVMThrow)
-  })
+    await this.helper.doFailingTransfer().should.be.rejectedWith(EVMThrow);
+  });
 
   it('should throw on failed transferFrom', async function () {
-    await this.helper.doFailingTransferFrom().should.be.rejectedWith(EVMThrow)
-  })
+    await this.helper.doFailingTransferFrom().should.be.rejectedWith(EVMThrow);
+  });
 
   it('should throw on failed approve', async function () {
-    await this.helper.doFailingApprove().should.be.rejectedWith(EVMThrow)
-  })
+    await this.helper.doFailingApprove().should.be.rejectedWith(EVMThrow);
+  });
 
   it('should not throw on succeeding transfer', async function () {
-    await this.helper.doSucceedingTransfer().should.be.fulfilled
-  })
+    await this.helper.doSucceedingTransfer().should.be.fulfilled;
+  });
 
   it('should not throw on succeeding transferFrom', async function () {
-    await this.helper.doSucceedingTransferFrom().should.be.fulfilled
-  })
+    await this.helper.doSucceedingTransferFrom().should.be.fulfilled;
+  });
 
   it('should not throw on succeeding approve', async function () {
-    await this.helper.doSucceedingApprove().should.be.fulfilled
-  })
-})
+    await this.helper.doSucceedingApprove().should.be.fulfilled;
+  });
+});
diff --git a/test/SafeMath.test.js b/test/SafeMath.test.js
index 05eca2ee9c0..f2faaf638a1 100644
--- a/test/SafeMath.test.js
+++ b/test/SafeMath.test.js
@@ -1,70 +1,70 @@
-const assertRevert = require('./helpers/assertRevert')
-const assertJump = require('./helpers/assertJump')
-var SafeMathMock = artifacts.require('./mocks/SafeMathMock.sol')
+const assertRevert = require('./helpers/assertRevert');
+const assertJump = require('./helpers/assertJump');
+var SafeMathMock = artifacts.require('./mocks/SafeMathMock.sol');
 
 contract('SafeMath', function (accounts) {
-  let safeMath
+  let safeMath;
 
   before(async function () {
-    safeMath = await SafeMathMock.new()
-  })
+    safeMath = await SafeMathMock.new();
+  });
 
   it('multiplies correctly', async function () {
-    let a = 5678
-    let b = 1234
-    await safeMath.multiply(a, b)
-    let result = await safeMath.result()
-    assert.equal(result, a * b)
-  })
+    let a = 5678;
+    let b = 1234;
+    await safeMath.multiply(a, b);
+    let result = await safeMath.result();
+    assert.equal(result, a * b);
+  });
 
   it('adds correctly', async function () {
-    let a = 5678
-    let b = 1234
-    await safeMath.add(a, b)
-    let result = await safeMath.result()
+    let a = 5678;
+    let b = 1234;
+    await safeMath.add(a, b);
+    let result = await safeMath.result();
 
-    assert.equal(result, a + b)
-  })
+    assert.equal(result, a + b);
+  });
 
   it('subtracts correctly', async function () {
-    let a = 5678
-    let b = 1234
-    await safeMath.subtract(a, b)
-    let result = await safeMath.result()
+    let a = 5678;
+    let b = 1234;
+    await safeMath.subtract(a, b);
+    let result = await safeMath.result();
 
-    assert.equal(result, a - b)
-  })
+    assert.equal(result, a - b);
+  });
 
   it('should throw an error if subtraction result would be negative', async function () {
-    let a = 1234
-    let b = 5678
+    let a = 1234;
+    let b = 5678;
     try {
-      await safeMath.subtract(a, b)
-      assert.fail('should have thrown before')
+      await safeMath.subtract(a, b);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertJump(error)
+      assertJump(error);
     }
-  })
+  });
 
   it('should throw an error on addition overflow', async function () {
-    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639935
-    let b = 1
+    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
+    let b = 1;
     try {
-      await safeMath.add(a, b)
-      assert.fail('should have thrown before')
+      await safeMath.add(a, b);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should throw an error on multiplication overflow', async function () {
-    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639933
-    let b = 2
+    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639933;
+    let b = 2;
     try {
-      await safeMath.multiply(a, b)
-      assert.fail('should have thrown before')
+      await safeMath.multiply(a, b);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/SampleCrowdsale.test.js b/test/SampleCrowdsale.test.js
index c5b6cd2ff24..9e3970ed817 100644
--- a/test/SampleCrowdsale.test.js
+++ b/test/SampleCrowdsale.test.js
@@ -1,108 +1,108 @@
-import ether from './helpers/ether'
-import { advanceBlock } from './helpers/advanceToBlock'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
-import latestTime from './helpers/latestTime'
-import EVMRevert from './helpers/EVMRevert'
+import ether from './helpers/ether';
+import { advanceBlock } from './helpers/advanceToBlock';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
+import latestTime from './helpers/latestTime';
+import EVMRevert from './helpers/EVMRevert';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const SampleCrowdsale = artifacts.require('SampleCrowdsale')
-const SampleCrowdsaleToken = artifacts.require('SampleCrowdsaleToken')
+const SampleCrowdsale = artifacts.require('SampleCrowdsale');
+const SampleCrowdsaleToken = artifacts.require('SampleCrowdsaleToken');
 
 contract('SampleCrowdsale', function ([owner, wallet, investor]) {
-  const RATE = new BigNumber(10)
-  const GOAL = ether(10)
-  const CAP = ether(20)
+  const RATE = new BigNumber(10);
+  const GOAL = ether(10);
+  const CAP = ether(20);
 
   before(async function () {
     // Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
-    await advanceBlock()
-  })
+    await advanceBlock();
+  });
 
   beforeEach(async function () {
-    this.startTime = latestTime() + duration.weeks(1)
-    this.endTime = this.startTime + duration.weeks(1)
-    this.afterEndTime = this.endTime + duration.seconds(1)
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime = this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1);
 
-    this.crowdsale = await SampleCrowdsale.new(this.startTime, this.endTime, RATE, GOAL, CAP, wallet)
-    this.token = SampleCrowdsaleToken.at(await this.crowdsale.token())
-  })
+    this.crowdsale = await SampleCrowdsale.new(this.startTime, this.endTime, RATE, GOAL, CAP, wallet);
+    this.token = SampleCrowdsaleToken.at(await this.crowdsale.token());
+  });
 
   it('should create crowdsale with correct parameters', async function () {
-    this.crowdsale.should.exist
-    this.token.should.exist
-
-    const startTime = await this.crowdsale.startTime()
-    const endTime = await this.crowdsale.endTime()
-    const rate = await this.crowdsale.rate()
-    const walletAddress = await this.crowdsale.wallet()
-    const goal = await this.crowdsale.goal()
-    const cap = await this.crowdsale.cap()
-
-    startTime.should.be.bignumber.equal(this.startTime)
-    endTime.should.be.bignumber.equal(this.endTime)
-    rate.should.be.bignumber.equal(RATE)
-    walletAddress.should.be.equal(wallet)
-    goal.should.be.bignumber.equal(GOAL)
-    cap.should.be.bignumber.equal(CAP)
-  })
+    this.crowdsale.should.exist;
+    this.token.should.exist;
+
+    const startTime = await this.crowdsale.startTime();
+    const endTime = await this.crowdsale.endTime();
+    const rate = await this.crowdsale.rate();
+    const walletAddress = await this.crowdsale.wallet();
+    const goal = await this.crowdsale.goal();
+    const cap = await this.crowdsale.cap();
+
+    startTime.should.be.bignumber.equal(this.startTime);
+    endTime.should.be.bignumber.equal(this.endTime);
+    rate.should.be.bignumber.equal(RATE);
+    walletAddress.should.be.equal(wallet);
+    goal.should.be.bignumber.equal(GOAL);
+    cap.should.be.bignumber.equal(CAP);
+  });
 
   it('should not accept payments before start', async function () {
-    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMRevert)
-    await this.crowdsale.buyTokens(investor, { from: investor, value: ether(1) }).should.be.rejectedWith(EVMRevert)
-  })
+    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMRevert);
+    await this.crowdsale.buyTokens(investor, { from: investor, value: ether(1) }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should accept payments during the sale', async function () {
-    const investmentAmount = ether(1)
-    const expectedTokenAmount = RATE.mul(investmentAmount)
+    const investmentAmount = ether(1);
+    const expectedTokenAmount = RATE.mul(investmentAmount);
 
-    await increaseTimeTo(this.startTime)
+    await increaseTimeTo(this.startTime);
     await this.crowdsale.buyTokens(investor, { value: investmentAmount, from: investor }).should.be.fulfilled;
 
     (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
-    (await this.token.totalSupply()).should.be.bignumber.equal(expectedTokenAmount)
-  })
+    (await this.token.totalSupply()).should.be.bignumber.equal(expectedTokenAmount);
+  });
 
   it('should reject payments after end', async function () {
-    await increaseTimeTo(this.afterEnd)
-    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMRevert)
-    await this.crowdsale.buyTokens(investor, { value: ether(1), from: investor }).should.be.rejectedWith(EVMRevert)
-  })
+    await increaseTimeTo(this.afterEnd);
+    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMRevert);
+    await this.crowdsale.buyTokens(investor, { value: ether(1), from: investor }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should reject payments over cap', async function () {
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.send(CAP)
-    await this.crowdsale.send(1).should.be.rejectedWith(EVMRevert)
-  })
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.send(CAP);
+    await this.crowdsale.send(1).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should allow finalization and transfer funds to wallet if the goal is reached', async function () {
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.send(GOAL)
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.send(GOAL);
 
-    const beforeFinalization = web3.eth.getBalance(wallet)
-    await increaseTimeTo(this.afterEndTime)
-    await this.crowdsale.finalize({ from: owner })
-    const afterFinalization = web3.eth.getBalance(wallet)
+    const beforeFinalization = web3.eth.getBalance(wallet);
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.finalize({ from: owner });
+    const afterFinalization = web3.eth.getBalance(wallet);
 
-    afterFinalization.minus(beforeFinalization).should.be.bignumber.equal(GOAL)
-  })
+    afterFinalization.minus(beforeFinalization).should.be.bignumber.equal(GOAL);
+  });
 
   it('should allow refunds if the goal is not reached', async function () {
-    const balanceBeforeInvestment = web3.eth.getBalance(investor)
+    const balanceBeforeInvestment = web3.eth.getBalance(investor);
 
-    await increaseTimeTo(this.startTime)
-    await this.crowdsale.sendTransaction({ value: ether(1), from: investor, gasPrice: 0 })
-    await increaseTimeTo(this.afterEndTime)
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.sendTransaction({ value: ether(1), from: investor, gasPrice: 0 });
+    await increaseTimeTo(this.afterEndTime);
 
-    await this.crowdsale.finalize({ from: owner })
-    await this.crowdsale.claimRefund({ from: investor, gasPrice: 0 }).should.be.fulfilled
+    await this.crowdsale.finalize({ from: owner });
+    await this.crowdsale.claimRefund({ from: investor, gasPrice: 0 }).should.be.fulfilled;
 
-    const balanceAfterRefund = web3.eth.getBalance(investor)
-    balanceBeforeInvestment.should.be.bignumber.equal(balanceAfterRefund)
-  })
-})
+    const balanceAfterRefund = web3.eth.getBalance(investor);
+    balanceBeforeInvestment.should.be.bignumber.equal(balanceAfterRefund);
+  });
+});
diff --git a/test/SplitPayment.test.js b/test/SplitPayment.test.js
index 069b4f633e7..0a8987ea439 100644
--- a/test/SplitPayment.test.js
+++ b/test/SplitPayment.test.js
@@ -1,78 +1,78 @@
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const EVMThrow = require('./helpers/EVMThrow.js')
-const SplitPayment = artifacts.require('../contracts/payment/SplitPayment.sol')
+const EVMThrow = require('./helpers/EVMThrow.js');
+const SplitPayment = artifacts.require('../contracts/payment/SplitPayment.sol');
 
 contract('SplitPayment', function ([owner, payee1, payee2, payee3, nonpayee1, payer1]) {
-  const amount = web3.toWei(1.0, 'ether')
+  const amount = web3.toWei(1.0, 'ether');
 
   beforeEach(async function () {
-    this.payees = [payee1, payee2, payee3]
-    this.shares = [20, 10, 70]
+    this.payees = [payee1, payee2, payee3];
+    this.shares = [20, 10, 70];
 
-    this.contract = await SplitPayment.new(this.payees, this.shares)
-  })
+    this.contract = await SplitPayment.new(this.payees, this.shares);
+  });
 
   it('should accept payments', async function () {
-    await web3.eth.sendTransaction({ from: owner, to: this.contract.address, value: amount })
+    await web3.eth.sendTransaction({ from: owner, to: this.contract.address, value: amount });
 
-    const balance = web3.eth.getBalance(this.contract.address)
-    balance.should.be.bignumber.equal(amount)
-  })
+    const balance = web3.eth.getBalance(this.contract.address);
+    balance.should.be.bignumber.equal(amount);
+  });
 
   it('should store shares if address is payee', async function () {
-    const shares = await this.contract.shares.call(payee1)
-    shares.should.be.bignumber.not.equal(0)
-  })
+    const shares = await this.contract.shares.call(payee1);
+    shares.should.be.bignumber.not.equal(0);
+  });
 
   it('should not store shares if address is not payee', async function () {
-    const shares = await this.contract.shares.call(nonpayee1)
-    shares.should.be.bignumber.equal(0)
-  })
+    const shares = await this.contract.shares.call(nonpayee1);
+    shares.should.be.bignumber.equal(0);
+  });
 
   it('should throw if no funds to claim', async function () {
-    await this.contract.claim({ from: payee1 }).should.be.rejectedWith(EVMThrow)
-  })
+    await this.contract.claim({ from: payee1 }).should.be.rejectedWith(EVMThrow);
+  });
 
   it('should throw if non-payee want to claim', async function () {
-    await web3.eth.sendTransaction({ from: payer1, to: this.contract.address, value: amount })
-    await this.contract.claim({ from: nonpayee1 }).should.be.rejectedWith(EVMThrow)
-  })
+    await web3.eth.sendTransaction({ from: payer1, to: this.contract.address, value: amount });
+    await this.contract.claim({ from: nonpayee1 }).should.be.rejectedWith(EVMThrow);
+  });
 
   it('should distribute funds to payees', async function () {
-    await web3.eth.sendTransaction({ from: payer1, to: this.contract.address, value: amount })
+    await web3.eth.sendTransaction({ from: payer1, to: this.contract.address, value: amount });
 
     // receive funds
-    const initBalance = web3.eth.getBalance(this.contract.address)
-    initBalance.should.be.bignumber.equal(amount)
+    const initBalance = web3.eth.getBalance(this.contract.address);
+    initBalance.should.be.bignumber.equal(amount);
 
     // distribute to payees
-    const initAmount1 = web3.eth.getBalance(payee1)
-    await this.contract.claim({ from: payee1 })
-    const profit1 = web3.eth.getBalance(payee1) - initAmount1
-    assert(Math.abs(profit1 - web3.toWei(0.20, 'ether')) < 1e16)
+    const initAmount1 = web3.eth.getBalance(payee1);
+    await this.contract.claim({ from: payee1 });
+    const profit1 = web3.eth.getBalance(payee1) - initAmount1;
+    assert(Math.abs(profit1 - web3.toWei(0.20, 'ether')) < 1e16);
 
-    const initAmount2 = web3.eth.getBalance(payee2)
-    await this.contract.claim({ from: payee2 })
-    const profit2 = web3.eth.getBalance(payee2) - initAmount2
-    assert(Math.abs(profit2 - web3.toWei(0.10, 'ether')) < 1e16)
+    const initAmount2 = web3.eth.getBalance(payee2);
+    await this.contract.claim({ from: payee2 });
+    const profit2 = web3.eth.getBalance(payee2) - initAmount2;
+    assert(Math.abs(profit2 - web3.toWei(0.10, 'ether')) < 1e16);
 
-    const initAmount3 = web3.eth.getBalance(payee3)
-    await this.contract.claim({ from: payee3 })
-    const profit3 = web3.eth.getBalance(payee3) - initAmount3
-    assert(Math.abs(profit3 - web3.toWei(0.70, 'ether')) < 1e16)
+    const initAmount3 = web3.eth.getBalance(payee3);
+    await this.contract.claim({ from: payee3 });
+    const profit3 = web3.eth.getBalance(payee3) - initAmount3;
+    assert(Math.abs(profit3 - web3.toWei(0.70, 'ether')) < 1e16);
 
     // end balance should be zero
-    const endBalance = web3.eth.getBalance(this.contract.address)
-    endBalance.should.be.bignumber.equal(0)
+    const endBalance = web3.eth.getBalance(this.contract.address);
+    endBalance.should.be.bignumber.equal(0);
 
     // check correct funds released accounting
-    const totalReleased = await this.contract.totalReleased.call()
-    totalReleased.should.be.bignumber.equal(initBalance)
-  })
-})
+    const totalReleased = await this.contract.totalReleased.call();
+    totalReleased.should.be.bignumber.equal(initBalance);
+  });
+});
diff --git a/test/StandardToken.test.js b/test/StandardToken.test.js
index 85f8c79136c..f7461da089f 100644
--- a/test/StandardToken.test.js
+++ b/test/StandardToken.test.js
@@ -1,128 +1,128 @@
 
-const assertRevert = require('./helpers/assertRevert')
+const assertRevert = require('./helpers/assertRevert');
 
-var StandardTokenMock = artifacts.require('./mocks/StandardTokenMock.sol')
+var StandardTokenMock = artifacts.require('./mocks/StandardTokenMock.sol');
 
 contract('StandardToken', function (accounts) {
-  let token
+  let token;
 
   beforeEach(async function () {
-    token = await StandardTokenMock.new(accounts[0], 100)
-  })
+    token = await StandardTokenMock.new(accounts[0], 100);
+  });
 
   it('should return the correct totalSupply after construction', async function () {
-    let totalSupply = await token.totalSupply()
+    let totalSupply = await token.totalSupply();
 
-    assert.equal(totalSupply, 100)
-  })
+    assert.equal(totalSupply, 100);
+  });
 
   it('should return the correct allowance amount after approval', async function () {
-    let token = await StandardTokenMock.new()
-    await token.approve(accounts[1], 100)
-    let allowance = await token.allowance(accounts[0], accounts[1])
+    let token = await StandardTokenMock.new();
+    await token.approve(accounts[1], 100);
+    let allowance = await token.allowance(accounts[0], accounts[1]);
 
-    assert.equal(allowance, 100)
-  })
+    assert.equal(allowance, 100);
+  });
 
   it('should return correct balances after transfer', async function () {
-    let token = await StandardTokenMock.new(accounts[0], 100)
-    await token.transfer(accounts[1], 100)
-    let balance0 = await token.balanceOf(accounts[0])
-    assert.equal(balance0, 0)
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    await token.transfer(accounts[1], 100);
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
 
-    let balance1 = await token.balanceOf(accounts[1])
-    assert.equal(balance1, 100)
-  })
+    let balance1 = await token.balanceOf(accounts[1]);
+    assert.equal(balance1, 100);
+  });
 
   it('should throw an error when trying to transfer more than balance', async function () {
-    let token = await StandardTokenMock.new(accounts[0], 100)
+    let token = await StandardTokenMock.new(accounts[0], 100);
     try {
-      await token.transfer(accounts[1], 101)
-      assert.fail('should have thrown before')
+      await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should return correct balances after transfering from another account', async function () {
-    let token = await StandardTokenMock.new(accounts[0], 100)
-    await token.approve(accounts[1], 100)
-    await token.transferFrom(accounts[0], accounts[2], 100, { from: accounts[1] })
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    await token.approve(accounts[1], 100);
+    await token.transferFrom(accounts[0], accounts[2], 100, { from: accounts[1] });
 
-    let balance0 = await token.balanceOf(accounts[0])
-    assert.equal(balance0, 0)
+    let balance0 = await token.balanceOf(accounts[0]);
+    assert.equal(balance0, 0);
 
-    let balance1 = await token.balanceOf(accounts[2])
-    assert.equal(balance1, 100)
+    let balance1 = await token.balanceOf(accounts[2]);
+    assert.equal(balance1, 100);
 
-    let balance2 = await token.balanceOf(accounts[1])
-    assert.equal(balance2, 0)
-  })
+    let balance2 = await token.balanceOf(accounts[1]);
+    assert.equal(balance2, 0);
+  });
 
   it('should throw an error when trying to transfer more than allowed', async function () {
-    await token.approve(accounts[1], 99)
+    await token.approve(accounts[1], 99);
     try {
-      await token.transferFrom(accounts[0], accounts[2], 100, { from: accounts[1] })
-      assert.fail('should have thrown before')
+      await token.transferFrom(accounts[0], accounts[2], 100, { from: accounts[1] });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should throw an error when trying to transferFrom more than _from has', async function () {
-    let balance0 = await token.balanceOf(accounts[0])
-    await token.approve(accounts[1], 99)
+    let balance0 = await token.balanceOf(accounts[0]);
+    await token.approve(accounts[1], 99);
     try {
-      await token.transferFrom(accounts[0], accounts[2], balance0 + 1, { from: accounts[1] })
-      assert.fail('should have thrown before')
+      await token.transferFrom(accounts[0], accounts[2], balance0 + 1, { from: accounts[1] });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   describe('validating allowance updates to spender', function () {
-    let preApproved
+    let preApproved;
 
     it('should start with zero', async function () {
-      preApproved = await token.allowance(accounts[0], accounts[1])
-      assert.equal(preApproved, 0)
-    })
+      preApproved = await token.allowance(accounts[0], accounts[1]);
+      assert.equal(preApproved, 0);
+    });
 
     it('should increase by 50 then decrease by 10', async function () {
-      await token.increaseApproval(accounts[1], 50)
-      let postIncrease = await token.allowance(accounts[0], accounts[1])
-      preApproved.plus(50).should.be.bignumber.equal(postIncrease)
-      await token.decreaseApproval(accounts[1], 10)
-      let postDecrease = await token.allowance(accounts[0], accounts[1])
-      postIncrease.minus(10).should.be.bignumber.equal(postDecrease)
-    })
-  })
+      await token.increaseApproval(accounts[1], 50);
+      let postIncrease = await token.allowance(accounts[0], accounts[1]);
+      preApproved.plus(50).should.be.bignumber.equal(postIncrease);
+      await token.decreaseApproval(accounts[1], 10);
+      let postDecrease = await token.allowance(accounts[0], accounts[1]);
+      postIncrease.minus(10).should.be.bignumber.equal(postDecrease);
+    });
+  });
 
   it('should increase by 50 then set to 0 when decreasing by more than 50', async function () {
-    await token.approve(accounts[1], 50)
-    await token.decreaseApproval(accounts[1], 60)
-    let postDecrease = await token.allowance(accounts[0], accounts[1])
-    postDecrease.should.be.bignumber.equal(0)
-  })
+    await token.approve(accounts[1], 50);
+    await token.decreaseApproval(accounts[1], 60);
+    let postDecrease = await token.allowance(accounts[0], accounts[1]);
+    postDecrease.should.be.bignumber.equal(0);
+  });
 
   it('should throw an error when trying to transfer to 0x0', async function () {
-    let token = await StandardTokenMock.new(accounts[0], 100)
+    let token = await StandardTokenMock.new(accounts[0], 100);
     try {
-      await token.transfer(0x0, 100)
-      assert.fail('should have thrown before')
+      await token.transfer(0x0, 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
+  });
 
   it('should throw an error when trying to transferFrom to 0x0', async function () {
-    let token = await StandardTokenMock.new(accounts[0], 100)
-    await token.approve(accounts[1], 100)
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    await token.approve(accounts[1], 100);
     try {
-      await token.transferFrom(accounts[0], 0x0, 100, { from: accounts[1] })
-      assert.fail('should have thrown before')
+      await token.transferFrom(accounts[0], 0x0, 100, { from: accounts[1] });
+      assert.fail('should have thrown before');
     } catch (error) {
-      assertRevert(error)
+      assertRevert(error);
     }
-  })
-})
+  });
+});
diff --git a/test/TokenDestructible.test.js b/test/TokenDestructible.test.js
index af2086797d3..a5b5ae77cc9 100644
--- a/test/TokenDestructible.test.js
+++ b/test/TokenDestructible.test.js
@@ -1,34 +1,34 @@
 
-var TokenDestructible = artifacts.require('../contracts/lifecycle/TokenDestructible.sol')
-var StandardTokenMock = artifacts.require('./mocks/StandardTokenMock.sol')
-require('./helpers/transactionMined.js')
+var TokenDestructible = artifacts.require('../contracts/lifecycle/TokenDestructible.sol');
+var StandardTokenMock = artifacts.require('./mocks/StandardTokenMock.sol');
+require('./helpers/transactionMined.js');
 
 contract('TokenDestructible', function (accounts) {
-  let destructible
+  let destructible;
 
   beforeEach(async function () {
-    destructible = await TokenDestructible.new({ fron: accounts[0], value: web3.toWei('10', 'ether') })
-  })
+    destructible = await TokenDestructible.new({ fron: accounts[0], value: web3.toWei('10', 'ether') });
+  });
 
   it('should send balance to owner after destruction', async function () {
-    let owner = await destructible.owner()
-    let initBalance = web3.eth.getBalance(owner)
-    await destructible.destroy([], { from: owner })
-    let newBalance = web3.eth.getBalance(owner)
-    assert.isTrue(newBalance > initBalance)
-  })
+    let owner = await destructible.owner();
+    let initBalance = web3.eth.getBalance(owner);
+    await destructible.destroy([], { from: owner });
+    let newBalance = web3.eth.getBalance(owner);
+    assert.isTrue(newBalance > initBalance);
+  });
 
   it('should send tokens to owner after destruction', async function () {
-    let owner = await destructible.owner()
-    let token = await StandardTokenMock.new(destructible.address, 100)
-    let initContractBalance = await token.balanceOf(destructible.address)
-    let initOwnerBalance = await token.balanceOf(owner)
-    assert.equal(initContractBalance, 100)
-    assert.equal(initOwnerBalance, 0)
-    await destructible.destroy([token.address], { from: owner })
-    let newContractBalance = await token.balanceOf(destructible.address)
-    let newOwnerBalance = await token.balanceOf(owner)
-    assert.equal(newContractBalance, 0)
-    assert.equal(newOwnerBalance, 100)
-  })
-})
+    let owner = await destructible.owner();
+    let token = await StandardTokenMock.new(destructible.address, 100);
+    let initContractBalance = await token.balanceOf(destructible.address);
+    let initOwnerBalance = await token.balanceOf(owner);
+    assert.equal(initContractBalance, 100);
+    assert.equal(initOwnerBalance, 0);
+    await destructible.destroy([token.address], { from: owner });
+    let newContractBalance = await token.balanceOf(destructible.address);
+    let newOwnerBalance = await token.balanceOf(owner);
+    assert.equal(newContractBalance, 0);
+    assert.equal(newOwnerBalance, 100);
+  });
+});
diff --git a/test/TokenTimelock.test.js b/test/TokenTimelock.test.js
index 4245aae28e1..d7fbab990d9 100644
--- a/test/TokenTimelock.test.js
+++ b/test/TokenTimelock.test.js
@@ -1,54 +1,54 @@
-import latestTime from './helpers/latestTime'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
+import latestTime from './helpers/latestTime';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const MintableToken = artifacts.require('MintableToken')
-const TokenTimelock = artifacts.require('TokenTimelock')
+const MintableToken = artifacts.require('MintableToken');
+const TokenTimelock = artifacts.require('TokenTimelock');
 
 contract('TokenTimelock', function ([_, owner, beneficiary]) {
-  const amount = new BigNumber(100)
+  const amount = new BigNumber(100);
 
   beforeEach(async function () {
-    this.token = await MintableToken.new({ from: owner })
-    this.releaseTime = latestTime() + duration.years(1)
-    this.timelock = await TokenTimelock.new(this.token.address, beneficiary, this.releaseTime)
-    await this.token.mint(this.timelock.address, amount, { from: owner })
-  })
+    this.token = await MintableToken.new({ from: owner });
+    this.releaseTime = latestTime() + duration.years(1);
+    this.timelock = await TokenTimelock.new(this.token.address, beneficiary, this.releaseTime);
+    await this.token.mint(this.timelock.address, amount, { from: owner });
+  });
 
   it('cannot be released before time limit', async function () {
-    await this.timelock.release().should.be.rejected
-  })
+    await this.timelock.release().should.be.rejected;
+  });
 
   it('cannot be released just before time limit', async function () {
-    await increaseTimeTo(this.releaseTime - duration.seconds(3))
-    await this.timelock.release().should.be.rejected
-  })
+    await increaseTimeTo(this.releaseTime - duration.seconds(3));
+    await this.timelock.release().should.be.rejected;
+  });
 
   it('can be released just after limit', async function () {
-    await increaseTimeTo(this.releaseTime + duration.seconds(1))
-    await this.timelock.release().should.be.fulfilled
-    const balance = await this.token.balanceOf(beneficiary)
-    balance.should.be.bignumber.equal(amount)
-  })
+    await increaseTimeTo(this.releaseTime + duration.seconds(1));
+    await this.timelock.release().should.be.fulfilled;
+    const balance = await this.token.balanceOf(beneficiary);
+    balance.should.be.bignumber.equal(amount);
+  });
 
   it('can be released after time limit', async function () {
-    await increaseTimeTo(this.releaseTime + duration.years(1))
-    await this.timelock.release().should.be.fulfilled
-    const balance = await this.token.balanceOf(beneficiary)
-    balance.should.be.bignumber.equal(amount)
-  })
+    await increaseTimeTo(this.releaseTime + duration.years(1));
+    await this.timelock.release().should.be.fulfilled;
+    const balance = await this.token.balanceOf(beneficiary);
+    balance.should.be.bignumber.equal(amount);
+  });
 
   it('cannot be released twice', async function () {
-    await increaseTimeTo(this.releaseTime + duration.years(1))
-    await this.timelock.release().should.be.fulfilled
-    await this.timelock.release().should.be.rejected
-    const balance = await this.token.balanceOf(beneficiary)
-    balance.should.be.bignumber.equal(amount)
-  })
-})
+    await increaseTimeTo(this.releaseTime + duration.years(1));
+    await this.timelock.release().should.be.fulfilled;
+    await this.timelock.release().should.be.rejected;
+    const balance = await this.token.balanceOf(beneficiary);
+    balance.should.be.bignumber.equal(amount);
+  });
+});
diff --git a/test/TokenVesting.test.js b/test/TokenVesting.test.js
index 02d11946688..e767ae1a811 100644
--- a/test/TokenVesting.test.js
+++ b/test/TokenVesting.test.js
@@ -1,113 +1,113 @@
-import EVMRevert from './helpers/EVMRevert'
-import latestTime from './helpers/latestTime'
-import { increaseTimeTo, duration } from './helpers/increaseTime'
+import EVMRevert from './helpers/EVMRevert';
+import latestTime from './helpers/latestTime';
+import { increaseTimeTo, duration } from './helpers/increaseTime';
 
-const BigNumber = web3.BigNumber
+const BigNumber = web3.BigNumber;
 
 require('chai')
   .use(require('chai-as-promised'))
   .use(require('chai-bignumber')(BigNumber))
-  .should()
+  .should();
 
-const MintableToken = artifacts.require('MintableToken')
-const TokenVesting = artifacts.require('TokenVesting')
+const MintableToken = artifacts.require('MintableToken');
+const TokenVesting = artifacts.require('TokenVesting');
 
 contract('TokenVesting', function ([_, owner, beneficiary]) {
-  const amount = new BigNumber(1000)
+  const amount = new BigNumber(1000);
 
   beforeEach(async function () {
-    this.token = await MintableToken.new({ from: owner })
+    this.token = await MintableToken.new({ from: owner });
 
-    this.start = latestTime() + duration.minutes(1) // +1 minute so it starts after contract instantiation
-    this.cliff = duration.years(1)
-    this.duration = duration.years(2)
+    this.start = latestTime() + duration.minutes(1); // +1 minute so it starts after contract instantiation
+    this.cliff = duration.years(1);
+    this.duration = duration.years(2);
 
-    this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, true, { from: owner })
+    this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, true, { from: owner });
 
-    await this.token.mint(this.vesting.address, amount, { from: owner })
-  })
+    await this.token.mint(this.vesting.address, amount, { from: owner });
+  });
 
   it('cannot be released before cliff', async function () {
-    await this.vesting.release(this.token.address).should.be.rejectedWith(EVMRevert)
-  })
+    await this.vesting.release(this.token.address).should.be.rejectedWith(EVMRevert);
+  });
 
   it('can be released after cliff', async function () {
-    await increaseTimeTo(this.start + this.cliff + duration.weeks(1))
-    await this.vesting.release(this.token.address).should.be.fulfilled
-  })
+    await increaseTimeTo(this.start + this.cliff + duration.weeks(1));
+    await this.vesting.release(this.token.address).should.be.fulfilled;
+  });
 
   it('should release proper amount after cliff', async function () {
-    await increaseTimeTo(this.start + this.cliff)
+    await increaseTimeTo(this.start + this.cliff);
 
-    const { receipt } = await this.vesting.release(this.token.address)
-    const releaseTime = web3.eth.getBlock(receipt.blockNumber).timestamp
+    const { receipt } = await this.vesting.release(this.token.address);
+    const releaseTime = web3.eth.getBlock(receipt.blockNumber).timestamp;
 
-    const balance = await this.token.balanceOf(beneficiary)
-    balance.should.bignumber.equal(amount.mul(releaseTime - this.start).div(this.duration).floor())
-  })
+    const balance = await this.token.balanceOf(beneficiary);
+    balance.should.bignumber.equal(amount.mul(releaseTime - this.start).div(this.duration).floor());
+  });
 
   it('should linearly release tokens during vesting period', async function () {
-    const vestingPeriod = this.duration - this.cliff
-    const checkpoints = 4
+    const vestingPeriod = this.duration - this.cliff;
+    const checkpoints = 4;
 
     for (let i = 1; i <= checkpoints; i++) {
-      const now = this.start + this.cliff + i * (vestingPeriod / checkpoints)
-      await increaseTimeTo(now)
+      const now = this.start + this.cliff + i * (vestingPeriod / checkpoints);
+      await increaseTimeTo(now);
 
-      await this.vesting.release(this.token.address)
-      const balance = await this.token.balanceOf(beneficiary)
-      const expectedVesting = amount.mul(now - this.start).div(this.duration).floor()
+      await this.vesting.release(this.token.address);
+      const balance = await this.token.balanceOf(beneficiary);
+      const expectedVesting = amount.mul(now - this.start).div(this.duration).floor();
 
-      balance.should.bignumber.equal(expectedVesting)
+      balance.should.bignumber.equal(expectedVesting);
     }
-  })
+  });
 
   it('should have released all after end', async function () {
-    await increaseTimeTo(this.start + this.duration)
-    await this.vesting.release(this.token.address)
-    const balance = await this.token.balanceOf(beneficiary)
-    balance.should.bignumber.equal(amount)
-  })
+    await increaseTimeTo(this.start + this.duration);
+    await this.vesting.release(this.token.address);
+    const balance = await this.token.balanceOf(beneficiary);
+    balance.should.bignumber.equal(amount);
+  });
 
   it('should be revoked by owner if revocable is set', async function () {
-    await this.vesting.revoke(this.token.address, { from: owner }).should.be.fulfilled
-  })
+    await this.vesting.revoke(this.token.address, { from: owner }).should.be.fulfilled;
+  });
 
   it('should fail to be revoked by owner if revocable not set', async function () {
-    const vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, false, { from: owner })
-    await vesting.revoke(this.token.address, { from: owner }).should.be.rejectedWith(EVMRevert)
-  })
+    const vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, false, { from: owner });
+    await vesting.revoke(this.token.address, { from: owner }).should.be.rejectedWith(EVMRevert);
+  });
 
   it('should return the non-vested tokens when revoked by owner', async function () {
-    await increaseTimeTo(this.start + this.cliff + duration.weeks(12))
+    await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
 
-    const vested = await this.vesting.vestedAmount(this.token.address)
+    const vested = await this.vesting.vestedAmount(this.token.address);
 
-    await this.vesting.revoke(this.token.address, { from: owner })
+    await this.vesting.revoke(this.token.address, { from: owner });
 
-    const ownerBalance = await this.token.balanceOf(owner)
-    ownerBalance.should.bignumber.equal(amount.sub(vested))
-  })
+    const ownerBalance = await this.token.balanceOf(owner);
+    ownerBalance.should.bignumber.equal(amount.sub(vested));
+  });
 
   it('should keep the vested tokens when revoked by owner', async function () {
-    await increaseTimeTo(this.start + this.cliff + duration.weeks(12))
+    await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
 
-    const vestedPre = await this.vesting.vestedAmount(this.token.address)
+    const vestedPre = await this.vesting.vestedAmount(this.token.address);
 
-    await this.vesting.revoke(this.token.address, { from: owner })
+    await this.vesting.revoke(this.token.address, { from: owner });
 
-    const vestedPost = await this.vesting.vestedAmount(this.token.address)
+    const vestedPost = await this.vesting.vestedAmount(this.token.address);
 
-    vestedPre.should.bignumber.equal(vestedPost)
-  })
+    vestedPre.should.bignumber.equal(vestedPost);
+  });
 
   it('should fail to be revoked a second time', async function () {
-    await increaseTimeTo(this.start + this.cliff + duration.weeks(12))
+    await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
 
-    await this.vesting.vestedAmount(this.token.address)
+    await this.vesting.vestedAmount(this.token.address);
 
-    await this.vesting.revoke(this.token.address, { from: owner })
+    await this.vesting.revoke(this.token.address, { from: owner });
 
-    await this.vesting.revoke(this.token.address, { from: owner }).should.be.rejectedWith(EVMRevert)
-  })
-})
+    await this.vesting.revoke(this.token.address, { from: owner }).should.be.rejectedWith(EVMRevert);
+  });
+});
diff --git a/test/helpers/EVMRevert.js b/test/helpers/EVMRevert.js
index cae7feac2e5..9edcc9d5470 100644
--- a/test/helpers/EVMRevert.js
+++ b/test/helpers/EVMRevert.js
@@ -1 +1 @@
-export default 'revert'
+export default 'revert';
diff --git a/test/helpers/EVMThrow.js b/test/helpers/EVMThrow.js
index c75924f5209..abdbd4ef330 100644
--- a/test/helpers/EVMThrow.js
+++ b/test/helpers/EVMThrow.js
@@ -1 +1 @@
-export default 'invalid opcode'
+export default 'invalid opcode';
diff --git a/test/helpers/advanceToBlock.js b/test/helpers/advanceToBlock.js
index e99e2372ac0..a11dc92b9a5 100644
--- a/test/helpers/advanceToBlock.js
+++ b/test/helpers/advanceToBlock.js
@@ -5,18 +5,18 @@ export function advanceBlock () {
       method: 'evm_mine',
       id: Date.now(),
     }, (err, res) => {
-      return err ? reject(err) : resolve(res)
-    })
-  })
+      return err ? reject(err) : resolve(res);
+    });
+  });
 }
 
 // Advances the block number so that the last mined block is `number`.
 export default async function advanceToBlock (number) {
   if (web3.eth.blockNumber > number) {
-    throw Error(`block number ${number} is in the past (current is ${web3.eth.blockNumber})`)
+    throw Error(`block number ${number} is in the past (current is ${web3.eth.blockNumber})`);
   }
 
   while (web3.eth.blockNumber < number) {
-    await advanceBlock()
+    await advanceBlock();
   }
 }
diff --git a/test/helpers/assertJump.js b/test/helpers/assertJump.js
index ebdb541354f..bba098b0740 100644
--- a/test/helpers/assertJump.js
+++ b/test/helpers/assertJump.js
@@ -1,3 +1,3 @@
 module.exports = function (error) {
-  assert.isAbove(error.message.search('invalid opcode'), -1, 'Invalid opcode error must be returned')
-}
+  assert.isAbove(error.message.search('invalid opcode'), -1, 'Invalid opcode error must be returned');
+};
diff --git a/test/helpers/assertRevert.js b/test/helpers/assertRevert.js
index 11db3527f48..2e44d775f22 100644
--- a/test/helpers/assertRevert.js
+++ b/test/helpers/assertRevert.js
@@ -1,3 +1,3 @@
 module.exports = function (error) {
-  assert.isAbove(error.message.search('revert'), -1, 'Error containing "revert" must be returned')
-}
+  assert.isAbove(error.message.search('revert'), -1, 'Error containing "revert" must be returned');
+};
diff --git a/test/helpers/ether.js b/test/helpers/ether.js
index 00a6fe43a39..3b5d13f7dfe 100644
--- a/test/helpers/ether.js
+++ b/test/helpers/ether.js
@@ -1,3 +1,3 @@
 export default function ether (n) {
-  return new web3.BigNumber(web3.toWei(n, 'ether'))
+  return new web3.BigNumber(web3.toWei(n, 'ether'));
 }
diff --git a/test/helpers/expectThrow.js b/test/helpers/expectThrow.js
index eb87a707e5b..eafcad24067 100644
--- a/test/helpers/expectThrow.js
+++ b/test/helpers/expectThrow.js
@@ -1,21 +1,21 @@
 export default async promise => {
   try {
-    await promise
+    await promise;
   } catch (error) {
     // TODO: Check jump destination to destinguish between a throw
     //       and an actual invalid jump.
-    const invalidOpcode = error.message.search('invalid opcode') >= 0
+    const invalidOpcode = error.message.search('invalid opcode') >= 0;
     // TODO: When we contract A calls contract B, and B throws, instead
     //       of an 'invalid jump', we get an 'out of gas' error. How do
     //       we distinguish this from an actual out of gas event? (The
     //       testrpc log actually show an 'invalid jump' event.)
-    const outOfGas = error.message.search('out of gas') >= 0
-    const revert = error.message.search('revert') >= 0
+    const outOfGas = error.message.search('out of gas') >= 0;
+    const revert = error.message.search('revert') >= 0;
     assert(
       invalidOpcode || outOfGas || revert,
       'Expected throw, got \'' + error + '\' instead',
-    )
-    return
+    );
+    return;
   }
-  assert.fail('Expected throw not received')
-}
+  assert.fail('Expected throw not received');
+};
diff --git a/test/helpers/hashMessage.js b/test/helpers/hashMessage.js
index c9be347e4a9..6e8a1f74e7f 100644
--- a/test/helpers/hashMessage.js
+++ b/test/helpers/hashMessage.js
@@ -1,8 +1,8 @@
-import utils from 'ethereumjs-util'
+import utils from 'ethereumjs-util';
 
 // Hash and add same prefix to the hash that testrpc use.
 module.exports = function (message) {
-  const messageHex = Buffer.from(utils.sha3(message).toString('hex'), 'hex')
-  const prefix = utils.toBuffer('\u0019Ethereum Signed Message:\n' + messageHex.length.toString())
-  return utils.bufferToHex(utils.sha3(Buffer.concat([prefix, messageHex])))
-}
+  const messageHex = Buffer.from(utils.sha3(message).toString('hex'), 'hex');
+  const prefix = utils.toBuffer('\u0019Ethereum Signed Message:\n' + messageHex.length.toString());
+  return utils.bufferToHex(utils.sha3(Buffer.concat([prefix, messageHex])));
+};
diff --git a/test/helpers/increaseTime.js b/test/helpers/increaseTime.js
index 65e4792a646..a445fd4684c 100644
--- a/test/helpers/increaseTime.js
+++ b/test/helpers/increaseTime.js
@@ -1,8 +1,8 @@
-import latestTime from './latestTime'
+import latestTime from './latestTime';
 
 // Increases testrpc time by the passed duration in seconds
 export default function increaseTime (duration) {
-  const id = Date.now()
+  const id = Date.now();
 
   return new Promise((resolve, reject) => {
     web3.currentProvider.sendAsync({
@@ -11,17 +11,17 @@ export default function increaseTime (duration) {
       params: [duration],
       id: id,
     }, err1 => {
-      if (err1) return reject(err1)
+      if (err1) return reject(err1);
 
       web3.currentProvider.sendAsync({
         jsonrpc: '2.0',
         method: 'evm_mine',
         id: id + 1,
       }, (err2, res) => {
-        return err2 ? reject(err2) : resolve(res)
-      })
-    })
-  })
+        return err2 ? reject(err2) : resolve(res);
+      });
+    });
+  });
 }
 
 /**
@@ -32,17 +32,17 @@ export default function increaseTime (duration) {
  * @param target time in seconds
  */
 export function increaseTimeTo (target) {
-  let now = latestTime()
-  if (target < now) throw Error(`Cannot increase current time(${now}) to a moment in the past(${target})`)
-  let diff = target - now
-  return increaseTime(diff)
+  let now = latestTime();
+  if (target < now) throw Error(`Cannot increase current time(${now}) to a moment in the past(${target})`);
+  let diff = target - now;
+  return increaseTime(diff);
 }
 
 export const duration = {
-  seconds: function (val) { return val },
-  minutes: function (val) { return val * this.seconds(60) },
-  hours: function (val) { return val * this.minutes(60) },
-  days: function (val) { return val * this.hours(24) },
-  weeks: function (val) { return val * this.days(7) },
-  years: function (val) { return val * this.days(365) },
-}
+  seconds: function (val) { return val; },
+  minutes: function (val) { return val * this.seconds(60); },
+  hours: function (val) { return val * this.minutes(60); },
+  days: function (val) { return val * this.hours(24); },
+  weeks: function (val) { return val * this.days(7); },
+  years: function (val) { return val * this.days(365); },
+};
diff --git a/test/helpers/latestTime.js b/test/helpers/latestTime.js
index b1d130bb71e..219b54c74d5 100644
--- a/test/helpers/latestTime.js
+++ b/test/helpers/latestTime.js
@@ -1,4 +1,4 @@
 // Returns the time of the last mined block in seconds
 export default function latestTime () {
-  return web3.eth.getBlock('latest').timestamp
+  return web3.eth.getBlock('latest').timestamp;
 }
diff --git a/test/helpers/merkleTree.js b/test/helpers/merkleTree.js
index 4456f46feb0..24d9f72f912 100644
--- a/test/helpers/merkleTree.js
+++ b/test/helpers/merkleTree.js
@@ -1,131 +1,131 @@
-import { sha3, bufferToHex } from 'ethereumjs-util'
+import { sha3, bufferToHex } from 'ethereumjs-util';
 
 export default class MerkleTree {
   constructor (elements) {
     // Filter empty strings and hash elements
-    this.elements = elements.filter(el => el).map(el => sha3(el))
+    this.elements = elements.filter(el => el).map(el => sha3(el));
 
     // Deduplicate elements
-    this.elements = this.bufDedup(this.elements)
+    this.elements = this.bufDedup(this.elements);
     // Sort elements
-    this.elements.sort(Buffer.compare)
+    this.elements.sort(Buffer.compare);
 
     // Create layers
-    this.layers = this.getLayers(this.elements)
+    this.layers = this.getLayers(this.elements);
   }
 
   getLayers (elements) {
     if (elements.length === 0) {
-      return [['']]
+      return [['']];
     }
 
-    const layers = []
-    layers.push(elements)
+    const layers = [];
+    layers.push(elements);
 
     // Get next layer until we reach the root
     while (layers[layers.length - 1].length > 1) {
-      layers.push(this.getNextLayer(layers[layers.length - 1]))
+      layers.push(this.getNextLayer(layers[layers.length - 1]));
     }
 
-    return layers
+    return layers;
   }
 
   getNextLayer (elements) {
     return elements.reduce((layer, el, idx, arr) => {
       if (idx % 2 === 0) {
         // Hash the current element with its pair element
-        layer.push(this.combinedHash(el, arr[idx + 1]))
+        layer.push(this.combinedHash(el, arr[idx + 1]));
       }
 
-      return layer
-    }, [])
+      return layer;
+    }, []);
   }
 
   combinedHash (first, second) {
-    if (!first) { return second }
-    if (!second) { return first }
+    if (!first) { return second; }
+    if (!second) { return first; }
 
-    return sha3(this.sortAndConcat(first, second))
+    return sha3(this.sortAndConcat(first, second));
   }
 
   getRoot () {
-    return this.layers[this.layers.length - 1][0]
+    return this.layers[this.layers.length - 1][0];
   }
 
   getHexRoot () {
-    return bufferToHex(this.getRoot())
+    return bufferToHex(this.getRoot());
   }
 
   getProof (el) {
-    let idx = this.bufIndexOf(el, this.elements)
+    let idx = this.bufIndexOf(el, this.elements);
 
     if (idx === -1) {
-      throw new Error('Element does not exist in Merkle tree')
+      throw new Error('Element does not exist in Merkle tree');
     }
 
     return this.layers.reduce((proof, layer) => {
-      const pairElement = this.getPairElement(idx, layer)
+      const pairElement = this.getPairElement(idx, layer);
 
       if (pairElement) {
-        proof.push(pairElement)
+        proof.push(pairElement);
       }
 
-      idx = Math.floor(idx / 2)
+      idx = Math.floor(idx / 2);
 
-      return proof
-    }, [])
+      return proof;
+    }, []);
   }
 
   getHexProof (el) {
-    const proof = this.getProof(el)
+    const proof = this.getProof(el);
 
-    return this.bufArrToHex(proof)
+    return this.bufArrToHex(proof);
   }
 
   getPairElement (idx, layer) {
-    const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1
+    const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
 
     if (pairIdx < layer.length) {
-      return layer[pairIdx]
+      return layer[pairIdx];
     } else {
-      return null
+      return null;
     }
   }
 
   bufIndexOf (el, arr) {
-    let hash
+    let hash;
 
     // Convert element to 32 byte hash if it is not one already
     if (el.length !== 32 || !Buffer.isBuffer(el)) {
-      hash = sha3(el)
+      hash = sha3(el);
     } else {
-      hash = el
+      hash = el;
     }
 
     for (let i = 0; i < arr.length; i++) {
       if (hash.equals(arr[i])) {
-        return i
+        return i;
       }
     }
 
-    return -1
+    return -1;
   }
 
   bufDedup (elements) {
     return elements.filter((el, idx) => {
-      return this.bufIndexOf(el, elements) === idx
-    })
+      return this.bufIndexOf(el, elements) === idx;
+    });
   }
 
   bufArrToHex (arr) {
     if (arr.some(el => !Buffer.isBuffer(el))) {
-      throw new Error('Array is not an array of buffers')
+      throw new Error('Array is not an array of buffers');
     }
 
-    return '0x' + arr.map(el => el.toString('hex')).join('')
+    return '0x' + arr.map(el => el.toString('hex')).join('');
   }
 
   sortAndConcat (...args) {
-    return Buffer.concat([...args].sort(Buffer.compare))
+    return Buffer.concat([...args].sort(Buffer.compare));
   }
 }
diff --git a/test/helpers/toPromise.js b/test/helpers/toPromise.js
index 788b6989b8f..2e9bcfbd38c 100644
--- a/test/helpers/toPromise.js
+++ b/test/helpers/toPromise.js
@@ -1,4 +1,4 @@
 export default func =>
   (...args) =>
     new Promise((resolve, reject) =>
-      func(...args, (error, data) => error ? reject(error) : resolve(data)))
+      func(...args, (error, data) => error ? reject(error) : resolve(data)));
diff --git a/test/helpers/transactionMined.js b/test/helpers/transactionMined.js
index 87e745588df..45fadfbd3db 100644
--- a/test/helpers/transactionMined.js
+++ b/test/helpers/transactionMined.js
@@ -1,33 +1,33 @@
 
 // from https://gist.github.com/xavierlepretre/88682e871f4ad07be4534ae560692ee6
 module.export = web3.eth.transactionMined = function (txnHash, interval) {
-  var transactionReceiptAsync
-  interval = interval || 500
+  var transactionReceiptAsync;
+  interval = interval || 500;
   transactionReceiptAsync = function (txnHash, resolve, reject) {
     try {
-      var receipt = web3.eth.getTransactionReceipt(txnHash)
+      var receipt = web3.eth.getTransactionReceipt(txnHash);
       if (receipt === null) {
         setTimeout(function () {
-          transactionReceiptAsync(txnHash, resolve, reject)
-        }, interval)
+          transactionReceiptAsync(txnHash, resolve, reject);
+        }, interval);
       } else {
-        resolve(receipt)
+        resolve(receipt);
       }
     } catch (e) {
-      reject(e)
+      reject(e);
     }
-  }
+  };
 
   if (Array.isArray(txnHash)) {
-    var promises = []
+    var promises = [];
     txnHash.forEach(function (oneTxHash) {
       promises.push(
-        web3.eth.getTransactionReceiptMined(oneTxHash, interval))
-    })
-    return Promise.all(promises)
+        web3.eth.getTransactionReceiptMined(oneTxHash, interval));
+    });
+    return Promise.all(promises);
   } else {
     return new Promise(function (resolve, reject) {
-      transactionReceiptAsync(txnHash, resolve, reject)
-    })
+      transactionReceiptAsync(txnHash, resolve, reject);
+    });
   }
-}
+};
diff --git a/truffle-config.js b/truffle-config.js
index ab960410090..bddce4915f7 100644
--- a/truffle-config.js
+++ b/truffle-config.js
@@ -1,20 +1,20 @@
-require('dotenv').config()
-require('babel-register')
-require('babel-polyfill')
+require('dotenv').config();
+require('babel-register');
+require('babel-polyfill');
 
-const HDWalletProvider = require('truffle-hdwallet-provider')
+const HDWalletProvider = require('truffle-hdwallet-provider');
 
 const providerWithMnemonic = (mnemonic, rpcEndpoint) =>
-  new HDWalletProvider(mnemonic, rpcEndpoint)
+  new HDWalletProvider(mnemonic, rpcEndpoint);
 
 const infuraProvider = network => providerWithMnemonic(
   process.env.MNEMONIC,
   `https://${network}.infura.io/${process.env.INFURA_API_KEY}`
-)
+);
 
 const ropstenProvider = process.env.SOLIDITY_COVERAGE
   ? undefined
-  : infuraProvider('ropsten')
+  : infuraProvider('ropsten');
 
 module.exports = {
   networks: {
@@ -45,4 +45,4 @@ module.exports = {
       network_id: '*', // eslint-disable-line camelcase
     },
   },
-}
+};