General cleanup of buidler-ganache

Author: alcuadrado

Diff for: packages/buidler-ganache/.npmrc

@@ -0,0 +1 @@
+package-lock=false

Diff for: packages/buidler-ganache/README.md

@@ -1,63 +1,56 @@
 [![npm](https://img.shields.io/npm/v/@nomiclabs/buidler-ethers.svg)](https://www.npmjs.com/package/@nomiclabs/buidler-ethers)
 
 # buidler-ganache
-[Buidler](http://getbuidler.com) plugin to launch [ganache-core](https://github.com/trufflesuite/ganache-core) before running tests or run tasks.
+
+This Buidler plugin automatically starts and stop [Ganache](https://github.com/trufflesuite/ganache-core) when running
+tests or scripts.
 
 ## What
-This plugin hooks into the `TASK_TEST`/`TASK_RUN` pipeline to start ganache-cli before anything and stop it afterwards.
+
+This plugin creates an especial network named `ganache`. When this network is used, a Ganache server will be
+automatically started before running tests and scripts, and stopped when finished.
 
 ## Installation
+
 ```bash
-npm install @nomiclabs/buidler-ganache ganache-cli
+npm install @nomiclabs/buidler-ganache
 ```
 
 And add the following statement to your `buidler.config.js`:
+
 ```js
 usePlugin("@nomiclabs/buidler-ganache");
 ```
 
 ## Tasks
+
 This plugin creates no additional tasks.
 
 ## Environment extensions
-This plugin adds all ganache running configs (defaults and set by the config file) to the BRE.
-The default ganache options exposed are:
-```js
-defaultOptions = {
-    url: "http://127.0.0.1:8545",
-    gasPrice: 20000000000,
-    gasLimit: 6721975,
-    defaultBalanceEther: 100,
-    totalAccounts: 10,
-    hardfork: "petersburg",
-    allowUnlimitedContractSize: false,
-    locked: false,
-    hdPath: "m/44'/60'/0'/0/",
-    keepAliveTimeout: 5000
-}
-```  
 
+This plugin doesn't extend the Buidler Runtime Environment.
 
 ## Usage
+
 There are no additional steps you need to take for this plugin to work.
 
 ## Configuration
-Any configuration is optional. But here it's an example that you can ass to your `buidler.config.js` file.
+
+You can set any of the [Ganache's options](https://github.com/trufflesuite/ganache-core#options) through the `ganache`
+network config. All of them are supported, with the exception of `accounts`.
+
+This example sets a larger block gas limit and the default balance of Ganache's accounts.
+
 ```js
 module.exports = {
-    defaultNetwork: "ganache",
-    networks: {
-        ganache: {
-            url: "http://127.0.0.1:8555",
-            gasPrice: 20000000000,
-            gasLimit: 6000000000,
-            defaultBalanceEther: 10,
-            totalAccounts: 3,
-            mnemonic: "polar velvet stereo oval echo senior cause cruel tube hobby exact angry",
-        },
+  defaultNetwork: "ganache",
+  networks: {
+    ganache: {
+      gasLimit: 6000000000,
+      defaultBalanceEther: 10
     }
+  }
 };
 ```
-Here the list of all available options and constrains: [ganache-core options](https://github.com/trufflesuite/ganache-core#options).
-###
+
 Note: The `accounts` option it's not currently supported.

Diff for: packages/buidler-ganache/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomiclabs/buidler-ganache",
-  "version": "1.0.0-beta.9",
-  "description": "Buidler plugin for managing ganache",
+  "version": "1.0.0-beta.13",
+  "description": "Buidler plugin for managing Ganache",
   "homepage": "https://github.com/nomiclabs/buidler/tree/master/packages/buidler-ganache",
   "repository": "github:nomiclabs/buidler",
   "author": "Nomic Labs SRL",
@@ -39,13 +39,13 @@
     "ts-interface-checker": "^0.1.9"
   },
   "devDependencies": {
-    "@nomiclabs/buidler": "^1.0.0-beta.9",
+    "@nomiclabs/buidler": "^1.0.0-beta.13",
     "@types/debug": "^4.1.4",
     "@types/fs-extra": "^5.1.0",
     "chai": "^4.2.0",
     "ts-interface-builder": "^0.2.0"
   },
   "peerDependencies": {
-    "@nomiclabs/buidler": "^1.0.0-beta.9"
+    "@nomiclabs/buidler": "^1.0.0-beta.13"
   }
 }

Diff for: packages/buidler-ganache/src/ganache-service.ts

@@ -1,16 +1,51 @@
+import { BuidlerPluginError } from "@nomiclabs/buidler/internal/core/errors";
 import debug from "debug";
 import { URL } from "url";
 
 const log = debug("buidler:plugin:ganache-service");
-log.color = "6";
+
+declare interface GanacheOptions {
+  url: string;
+  keepAliveTimeout?: number;
+  accountKeysPath?: string; // Translates to: account_keys_path
+  accounts?: object[];
+  allowUnlimitedContractSize?: boolean;
+  blockTime?: number;
+  dbPath?: string; // Translates to: db_path
+  debug?: boolean;
+  defaultBalanceEther?: number; // Translates to: default_balance_ether
+  fork?: string | object;
+  forkBlockNumber?: string | number; // Translates to: fork_block_number
+  gasLimit?: number;
+  gasPrice?: string | number;
+  hardfork?: "byzantium" | "constantinople" | "petersburg";
+  hdPath?: string; // Translates to: hd_path
+  hostname?: string;
+  locked?: boolean;
+  logger?: {
+    log(msg: string): void;
+  };
+  mnemonic?: string;
+  networkId?: number;
+  port?: number;
+  seed?: any;
+  time?: any; // Date
+  totalAccounts?: number; // Translates to: total_accounts
+  unlockedAccounts?: string[]; // Translates to: unlocked_accounts
+  verbose?: boolean;
+  vmErrorsOnRPCResponse?: boolean;
+  ws?: boolean;
+}
+
+const DEFAULT_PORT = 7545;
 
 export class GanacheService {
-  public static error: Error;
+  public static error?: Error;
   public static optionValidator: any;
 
   public static getDefaultOptions(): GanacheOptions {
     return {
-      url: "http://127.0.0.1:8545",
+      url: `http://127.0.0.1:${DEFAULT_PORT}`,
       gasPrice: 20000000000,
       gasLimit: 6721975,
       defaultBalanceEther: 100,
@@ -54,13 +89,20 @@ export class GanacheService {
     } catch (e) {
       // Verify the expected error or throw it again
       if (e.name === "TypeError") {
-        e.message = "One or more invalid values in ganache network options";
-        if (!GanacheService.error) {
-          log(e.message || e);
-          GanacheService.error = e;
+        if (GanacheService.error === undefined) {
+          const error = new BuidlerPluginError(
+            `Ganache plugin config is invalid: ${e.message}`,
+            e
+          );
+
+          log("Failed to initialize GanacheService\n", error);
+          GanacheService.error = error;
         }
       } else {
-        throw e;
+        throw new BuidlerPluginError(
+          `Failed to initialize GanacheService: ${e.message}`,
+          e
+        );
       }
     }
   }
@@ -78,15 +120,31 @@ export class GanacheService {
 
       // Start server with current configs (port and hostname)
       await new Promise((resolve, reject) => {
-        this._server.once("listening", resolve);
-        this._server.once("error", reject);
+        let onError: (err: Error) => void;
+
+        const onListening = () => {
+          this._server.removeListener("error", onError);
+          resolve();
+        };
+
+        onError = err => {
+          this._server.removeListener("listening", onListening);
+          reject(err);
+        };
+
+        this._server.once("listening", onListening);
+        this._server.once("error", onError);
         this._server.listen(port, hostname);
       });
     } catch (e) {
-      e.message = `Start Server > ${e.message}`;
-      if (!GanacheService.error) {
-        log(e.message || e);
-        GanacheService.error = e;
+      const error = new BuidlerPluginError(
+        `Failed to start GanacheService: ${e.message}`,
+        e
+      );
+
+      if (GanacheService.error === undefined) {
+        log("Failed to start GanacheService\n", error);
+        GanacheService.error = error;
       }
     }
 
@@ -104,22 +162,25 @@ export class GanacheService {
       // Stop server and Wait for it
       await new Promise((resolve, reject) => {
         this._server.close((err: Error) => {
-          if (err) {
+          if (err !== undefined && err !== null) {
             reject(err);
           } else {
             resolve();
           }
         });
       });
     } catch (e) {
-      e.message = `Stop Server > ${e.message}`;
-      if (!GanacheService.error) {
-        log(e.message || e);
-        GanacheService.error = e;
+      const error = new BuidlerPluginError(
+        `Failed to stop GanacheService: ${e.message}`,
+        e
+      );
+
+      if (GanacheService.error === undefined) {
+        log("Failed to stop GanacheService\n", error);
+        GanacheService.error = error;
       }
     }
 
-    // Verify service state before continue (TODO Maybe extract this to a decorator)
     this._checkForServiceErrors();
   }
 
@@ -129,25 +190,33 @@ export class GanacheService {
     // Validate and parse hostname and port from URL (this validation is priority)
     const url = new URL(options.url);
     if (url.hostname !== "locahost" && url.hostname !== "127.0.0.1") {
-      throw new Error("Config: ganache.hostname must resolve to locahost");
+      throw new BuidlerPluginError("Ganache network only works with locahost");
     }
 
     // Validate all options agains validator
     try {
       GanacheService.optionValidator.check(options);
     } catch (e) {
-      e.message = e.message.replace("value.", "Config: ganache.");
-      throw e;
+      throw new BuidlerPluginError(
+        `Ganache network config is invalid: ${e.message}`,
+        e
+      );
     }
 
     // Test for unsupported commands
     if (options.accounts !== undefined) {
-      throw new Error("Config: ganache.accounts unsupported for this network");
+      throw new BuidlerPluginError(
+        "Config: ganache.accounts unsupported for this network"
+      );
     }
 
     // Transform needed options to Ganache core server (not using SnakeCase lib for performance)
     validatedOptions.hostname = url.hostname;
-    validatedOptions.port = Number(url.port) || 80;
+
+    validatedOptions.port =
+      url.port !== undefined && url.port !== ""
+        ? parseInt(url.port, 10)
+        : DEFAULT_PORT;
 
     const optionsToInclude = [
       "accountsKeyPath",
@@ -157,7 +226,7 @@ export class GanacheService {
       "unlockedAccounts"
     ];
     for (const [key, value] of Object.entries(options)) {
-      if (value && optionsToInclude.includes(key)) {
+      if (value !== undefined && optionsToInclude.includes(key)) {
         validatedOptions[this._snakeCase(key)] = value;
         delete validatedOptions[key];
       }
@@ -171,45 +240,27 @@ export class GanacheService {
 
     // Add listener for general server errors
     server.on("error", function(err: any) {
-      if (!GanacheService.error && err) {
-        log(err.message || err);
+      if (
+        GanacheService.error === undefined &&
+        err !== undefined &&
+        err !== null
+      ) {
+        log("An error occurred in GanacheService\n", err);
         GanacheService.error = err;
       }
     });
-
-    // Add listener for process uncaught errors (warning: this may catch non plugin related errors)
-    // process.on("uncaughtException", function(e) {
-    //   log("Uncaught Exception", e.message);
-    //   server.close(function(err: any) {
-    //     if (!GanacheService.error && err) {
-    //       log(err.message || err.stack || err);
-    //       GanacheService.error = err;
-    //     }
-    //   });
-    // });
-
-    // Add listener for standard POSIX signal SIGINT (usually generated with <Ctrl>+C)
-    // process.on("SIGINT", function() {
-    //   log("SIGINT detected");
-    //   server.close(function(err: any) {
-    //     if (!GanacheService.error && err) {
-    //       log(err.message || err.stack || err);
-    //       GanacheService.error = err;
-    //     }
-    //   });
-    // });
-
-    // TODO Maybe in the future, in new threat, some kind of ping checker to the server (every 30 seg)
   }
 
   private _checkForServiceErrors() {
-    if (GanacheService.error) {
-      // Close server (if needed)
-      if (this._server) {
+    if (GanacheService.error !== undefined) {
+      if (this._server !== undefined) {
         this._server.close();
       }
 
-      throw new Error(GanacheService.error.message);
+      throw new BuidlerPluginError(
+        `An error occurred in GanacheService: ${GanacheService.error.message}`,
+        GanacheService.error
+      );
     }
   }