BuidlerEVM JSON-RPC Server

packages/buidler-core/package.json

@@ -68,6 +68,7 @@
     "time-require": "^0.1.2"
   },
   "dependencies": {
+    "@nomiclabs/ethereumjs-vm": "^4.1.1",
     "@types/bn.js": "^4.11.5",
     "@types/lru-cache": "^5.1.0",
     "abort-controller": "^3.0.0",
@@ -86,7 +87,6 @@
     "ethereumjs-common": "^1.3.2",
     "ethereumjs-tx": "^2.1.1",
     "ethereumjs-util": "^6.1.0",
-    "@nomiclabs/ethereumjs-vm": "^4.1.1",
     "find-up": "^2.1.0",
     "fp-ts": "1.19.3",
     "fs-extra": "^7.0.1",
@@ -98,6 +98,7 @@
     "mocha": "^5.2.0",
     "node-fetch": "^2.6.0",
     "qs": "^6.7.0",
+    "raw-body": "^2.4.1",
     "semver": "^6.3.0",
     "solc": "0.5.15",
     "solidity-parser-antlr": "^0.4.2",

packages/buidler-core/src/builtin-tasks/jsonrpc.ts

@@ -0,0 +1,66 @@
+import debug from "debug";
+
+import {
+  JsonRpcServer,
+  JsonRpcServerConfig
+} from "../internal/buidler-evm/jsonrpc/server";
+import { BUIDLEREVM_NETWORK_NAME } from "../internal/constants";
+import { task } from "../internal/core/config/config-env";
+import { BuidlerError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
+import { createProvider } from "../internal/core/providers/construction";
+import { lazyObject } from "../internal/util/lazy";
+import { EthereumProvider, ResolvedBuidlerConfig } from "../types";
+
+import { TASK_JSONRPC } from "./task-names";
+
+const log = debug("buidler:core:tasks:jsonrpc");
+
+function _createBuidlerRuntimeEnvironment(
+  config: ResolvedBuidlerConfig
+): EthereumProvider {
+  log("Creating BuidlerRuntimeEnvironment");
+
+  const networkName = BUIDLEREVM_NETWORK_NAME;
+  const networkConfig = config.networks[networkName];
+
+  return lazyObject(() => {
+    log(`Creating buidlerevm provider for JSON-RPC sever`);
+    return createProvider(
+      networkName,
+      networkConfig,
+      config.solc.version,
+      config.paths
+    );
+  });
+}
+
+export default function() {
+  task(TASK_JSONRPC, "Starts a buidler JSON-RPC server").setAction(
+    async (_, { config }) => {
+      try {
+        const serverConfig: JsonRpcServerConfig = {
+          hostname: "localhost",
+          port: 8545,
+          ethereum: _createBuidlerRuntimeEnvironment(config)
+        };
+
+        const server = new JsonRpcServer(serverConfig);
+
+        process.exitCode = await server.listen();
+      } catch (error) {
+        if (BuidlerError.isBuidlerError(error)) {
+          throw error;
+        }
+
+        throw new BuidlerError(
+          ERRORS.BUILTIN_TASKS.JSONRPC_SERVER_ERROR,
+          {
+            error: error.message
+          },
+          error
+        );
+      }
+    }
+  );
+}

packages/buidler-core/src/builtin-tasks/task-names.ts

@@ -23,6 +23,8 @@ export const TASK_HELP = "help";
 
 export const TASK_RUN = "run";
 
+export const TASK_JSONRPC = "jsonrpc";
+
 export const TASK_TEST = "test";
 
 export const TASK_TEST_RUN_MOCHA_TESTS = "test:run-mocha-tests";

packages/buidler-core/src/internal/buidler-evm/jsonrpc/handler.ts

@@ -0,0 +1,166 @@
+import chalk from "chalk";
+import debug from "debug";
+import { IncomingMessage, ServerResponse } from "http";
+import getRawBody from "raw-body";
+
+import { EthereumProvider } from "../../../types";
+import { BUIDLER_NAME } from "../../constants";
+import { BuidlerError } from "../../core/errors";
+import { ERRORS, getErrorCode } from "../../core/errors-list";
+import {
+  isValidJsonRequest,
+  isValidJsonResponse,
+  JsonRpcRequest,
+  JsonRpcResponse
+} from "../../core/providers/http";
+import {
+  BuidlerEVMProviderError,
+  InternalError,
+  InvalidJsonInputError,
+  InvalidRequestError
+} from "../provider/errors";
+
+const log = debug("buidler:core:buidler-evm:jsonrpc");
+
+export default class JsonRpcHandler {
+  private _ethereum: EthereumProvider;
+
+  constructor(ethereum: EthereumProvider) {
+    this._ethereum = ethereum;
+  }
+
+  public requestListener = async (
+    req: IncomingMessage,
+    res: ServerResponse
+  ) => {
+    let rpcReq: JsonRpcRequest | undefined;
+    let rpcResp: JsonRpcResponse | undefined;
+
+    try {
+      rpcReq = await this._readRequest(req);
+
+      rpcResp = await this._handleRequest(rpcReq);
+    } catch (error) {
+      rpcResp = await this._handleError(error);
+    }
+
+    if (rpcReq !== undefined) {
+      rpcResp.id = rpcReq.id;
+    }
+
+    // Validate the RPC response.
+    if (!isValidJsonResponse(rpcResp)) {
+      rpcResp = await this._handleError(new InternalError("Internal error"));
+    }
+
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(rpcResp));
+  };
+
+  private _readRequest = async (
+    req: IncomingMessage
+  ): Promise<JsonRpcRequest> => {
+    const buf = await getRawBody(req);
+    const text = buf.toString();
+    let json;
+
+    try {
+      json = JSON.parse(text);
+    } catch (error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    if (!isValidJsonRequest(json)) {
+      throw new InvalidRequestError("Invalid request");
+    }
+
+    return json;
+  };
+
+  private _handleRequest = async (
+    req: JsonRpcRequest
+  ): Promise<JsonRpcResponse> => {
+    console.log(req.method);
+
+    const result = await this._ethereum.send(req.method, req.params);
+
+    return {
+      jsonrpc: "2.0",
+      id: req.id,
+      result
+    };
+  };
+
+  private _handleError = async (error: any): Promise<JsonRpcResponse> => {
+    this._printError(error);
+
+    const rpcResp: JsonRpcResponse = {
+      jsonrpc: "2.0",
+      error: {
+        code: error.code,
+        message: error.message
+      }
+    };
+
+    if (!(error instanceof BuidlerEVMProviderError)) {
+      rpcResp.error = new InternalError("Internal error");
+    }
+
+    return rpcResp;
+  };
+
+  private _printError = (error: any) => {
+    let showStackTraces = process.argv.includes("--show-stack-traces");
+    let isBuidlerError = false;
+
+    if (error instanceof BuidlerEVMProviderError) {
+      const wrappedError = new BuidlerError(
+        ERRORS.BUILTIN_TASKS.JSONRPC_HANDLER_ERROR,
+        {
+          error: error.message
+        },
+        error
+      );
+
+      console.error(chalk.red(`Error ${wrappedError.message}`));
+    } else if (BuidlerError.isBuidlerError(error)) {
+      isBuidlerError = true;
+      console.error(chalk.red(`Error ${error.message}`));
+    } else if (error instanceof Error) {
+      console.error(
+        chalk.red(`An unexpected error occurred: ${error.message}`)
+      );
+      showStackTraces = true;
+    } else {
+      console.error(chalk.red("An unexpected error occurred."));
+      showStackTraces = true;
+    }
+
+    console.log("");
+
+    if (showStackTraces) {
+      console.error(error.stack);
+    } else {
+      if (!isBuidlerError) {
+        console.error(
+          `If you think this is a bug in Buidler, please report it here: https://buidler.dev/reportbug`
+        );
+      }
+
+      if (BuidlerError.isBuidlerError(error)) {
+        const link = `https://buidler.dev/${getErrorCode(
+          error.errorDescriptor
+        )}`;
+
+        console.error(
+          `For more info go to ${link} or run ${BUIDLER_NAME} with --show-stack-traces`
+        );
+      } else {
+        console.error(
+          `For more info run ${BUIDLER_NAME} with --show-stack-traces`
+        );
+      }
+    }
+  };
+}

packages/buidler-core/src/internal/buidler-evm/jsonrpc/server.ts

@@ -0,0 +1,46 @@
+import debug from "debug";
+import * as http from "http";
+
+import { EthereumProvider } from "../../../types";
+
+import JsonRpcHandler from "./handler";
+
+const log = debug("buidler:core:buidler-evm:jsonrpc");
+
+export interface JsonRpcServerConfig {
+  hostname: string;
+  port: number;
+
+  ethereum: EthereumProvider;
+}
+
+export class JsonRpcServer {
+  private _config: JsonRpcServerConfig;
+
+  constructor(config: JsonRpcServerConfig) {
+    this._config = config;
+  }
+
+  public listen = (): Promise<number> => {
+    return new Promise<number>((resolve, reject) => {
+      const { hostname, port, ethereum } = this._config;
+
+      log(`Starting JSON-RPC server on port ${port}`);
+
+      const handler = new JsonRpcHandler(ethereum);
+      const server = http.createServer(handler.requestListener);
+
+      process.once("SIGINT", async () => {
+        log(`Stopping JSON-RPC server`);
+
+        resolve(0);
+      });
+
+      process.once("uncaughtException", reject);
+
+      server.listen(port, hostname, () => {
+        console.log(`Started JSON-RPC server at http://${hostname}:${port}/`);
+      });
+    });
+  };
+}

packages/buidler-core/src/internal/core/errors-list.ts

@@ -586,6 +586,18 @@ Please check Buidler's output for more details.`
       description: `Buidler flatten doesn't support cyclic dependencies. 
 
 We recommend not using this kind of dependencies.`
+    },
+    JSONRPC_SERVER_ERROR: {
+      number: 604,
+      message: "Error running JSON-RPC server: %error%",
+      title: "Error running JSON-RPC server",
+      description: `There was error while starting the JSON-RPC HTTP server.`
+    },
+    JSONRPC_HANDLER_ERROR: {
+      number: 605,
+      message: "Error handling JSON-RPC request: %error%",
+      title: "Error handling JSON-RPC request",
+      description: `Handling an incoming JSON-RPC request resulted in an error.`
     }
   },
   ARTIFACTS: {