Config -> rpc, rpcport, rpcaddr integration, some CLI cleanup, fixed RPCManager instantiation

Author: holgerd77

bin/cli.ts

@@ -7,7 +7,7 @@ import Node from '../lib/node'
 import { Server as RPCServer } from 'jayson'
 import { Config } from '../lib/config'
 import Common from '@ethereumjs/common'
-const RPCManager = require('../lib/rpc')
+import { RPCManager } from '../lib/rpc'
 const level = require('level')
 const path = require('path')
 const fs = require('fs-extra')
@@ -18,7 +18,7 @@ const args = require('yargs')
     network: {
       describe: `Network`,
       choices: networks.map((n) => n[1]),
-      default: networks[0][1],
+      default: 'mainnet',
     },
     'network-id': {
       describe: `Network ID`,
@@ -47,12 +47,12 @@ const args = require('yargs')
     rpc: {
       describe: 'Enable the JSON-RPC server',
       boolean: true,
-      default: false,
+      default: Config.RPC_DEFAULT,
     },
     rpcport: {
       describe: 'HTTP-RPC server listening port',
       number: true,
-      default: 8545,
+      default: Config.RPCPORT_DEFAULT,
     },
     rpcaddr: {
       describe: 'HTTP-RPC server listening interface',
@@ -81,53 +81,72 @@ const args = require('yargs')
   .locale('en_EN').argv
 const logger = getLogger({ loglevel: args.loglevel })
 
-async function runNode(options: any) {
+/**
+ * Initializes and starts a Node and reacts on the
+ * main node lifecycle events
+ * 
+ * @param config
+ */
+async function runNode(config: Config) {
+  const syncDataDir = config.getSyncDataDirectory()
+  fs.ensureDirSync(syncDataDir)
+  logger.info(`Sync data directory: ${syncDataDir}`)
+  
   logger.info('Initializing Ethereumjs client...')
-  if (options.config.lightserv) {
+  if (config.lightserv) {
     logger.info(`Serving light peer requests`)
   }
-  const node = new Node(options)
+  const node = new Node({
+    config,
+    db: level(syncDataDir),
+  })
   node.on('error', (err: any) => logger.error(err))
   node.on('listening', (details: any) => {
     logger.info(`Listener up transport=${details.transport} url=${details.url}`)
   })
   node.on('synchronized', () => {
     logger.info('Synchronized')
   })
-  logger.info(`Connecting to network: ${options.config.common.chainName()}`)
+  logger.info(`Connecting to network: ${config.common.chainName()}`)
   await node.open()
   logger.info('Synchronizing blockchain...')
   await node.start()
 
   return node
 }
 
-function runRpcServer(node: any, options: any) {
-  const { rpcport, rpcaddr } = options
-  const manager = new RPCManager(node, options)
+function runRpcServer(node: Node, config: Config) {
+  const { rpcport, rpcaddr } = config
+  const manager = new RPCManager(node, config)
   const server = new RPCServer(manager.getMethods())
   logger.info(`RPC HTTP endpoint opened: http://${rpcaddr}:${rpcport}`)
   server.http().listen(rpcport)
 
   return server
 }
 
+/**
+ * Main entry point to start a client
+ */
 async function run() {
   // give network id precedence over network name
+  let chain: string | number
   if (args.networkId) {
-    const network = networks.find((n) => n[0] === `${args.networkId}`)
-    if (network) {
-      args.network = network[1]
-    }
+    chain = args.networkId
+  } else {
+    chain = args.network
   }
 
-  const common = new Common({ chain: args.network, hardfork: 'chainstart' })
+  const common = new Common({ chain, hardfork: 'chainstart' })
   const config = new Config({
     common,
     logger,
     syncmode: args.syncmode,
     lightserv: args.lightserv,
     transports: args.transports,
+    rpc: args.rpc,
+    rpcport: args.rpcport,
+    rpcaddr: args.rpcaddr,
     minPeers: args.minPeers,
     maxPeers: args.maxPeers,
   })
@@ -136,18 +155,8 @@ async function run() {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const chainParams = args.params ? await parseParams(args.params) : args.network
 
-  const syncDataDir = config.getSyncDataDirectory()
-  fs.ensureDirSync(syncDataDir)
-  logger.info(`Sync data directory: ${syncDataDir}`)
-
-  const options = {
-    config,
-    db: level(syncDataDir),
-    rpcport: args.rpcport,
-    rpcaddr: args.rpcaddr,
-  }
-  const node = await runNode(options)
-  const server = args.rpc ? runRpcServer(node, options) : null
+  const node = await runNode(config)
+  const server = config.rpc ? runRpcServer(node, config) : null
 
   process.on('SIGINT', async () => {
     logger.info('Caught interrupt signal. Shutting down...')

lib/config.ts

@@ -47,6 +47,22 @@ export interface Options {
    * Default: servers created from `transports` option
    */
   servers?: (RlpxServer | Libp2pServer)[]
+  /**
+   * Enable the JSON-RPC server
+   * 
+   * Default: false
+   */
+  rpc?: boolean
+  /**
+   * HTTP-RPC server listening port
+   * 
+   * Default: 8545
+   */
+  rpcport?: number
+  /**
+   * HTTP-RPC server listening interface
+   */
+  rpcaddr?: string
   /**
    * Number of peers needed before syncing
    *
@@ -71,6 +87,9 @@ export class Config {
   public static readonly LIGHTSERV_DEFAULT = false
   public static readonly DATADIR_DEFAULT = `${os.homedir()}/Library/Ethereum`
   public static readonly TRANSPORTS_DEFAULT = ['rlpx:port=30303', 'libp2p']
+  public static readonly RPC_DEFAULT = false
+  public static readonly RPCPORT_DEFAULT = 8545
+  public static readonly RPCADDR_DEFAULT = 'localhost'
   public static readonly MINPEERS_DEFAULT = 2
   public static readonly MAXPEERS_DEFAULT = 25
 
@@ -80,6 +99,9 @@ export class Config {
   public readonly lightserv: boolean
   public readonly datadir: string
   public readonly transports: string[]
+  public readonly rpc: boolean
+  public readonly rpcport: number
+  public readonly rpcaddr: string
   public readonly minPeers: number
   public readonly maxPeers: number
 
@@ -93,6 +115,9 @@ export class Config {
     this.lightserv = options.lightserv ?? Config.LIGHTSERV_DEFAULT
     this.transports = options.transports ?? Config.TRANSPORTS_DEFAULT
     this.datadir = options.datadir ?? Config.DATADIR_DEFAULT
+    this.rpc = options.rpc ?? Config.RPC_DEFAULT
+    this.rpcport = options.rpcport ?? Config.RPCPORT_DEFAULT
+    this.rpcaddr = options.rpcaddr ?? Config.RPCADDR_DEFAULT
     this.minPeers = options.minPeers ?? Config.MINPEERS_DEFAULT
     this.maxPeers = options.maxPeers ?? Config.MAXPEERS_DEFAULT
 

lib/rpc/index.ts

@@ -1,3 +1,5 @@
+import { Config } from '../config'
+import Node from '../node'
 import * as modules from './modules'
 
 /**
@@ -19,11 +21,11 @@ function getMethodNames(mod: any): string[] {
  * @memberof module:rpc
  */
 export class RPCManager {
-  private _config: any
+  private _config: Config
   private _node: any
   private _logger: any
 
-  constructor(node: any, config: any) {
+  constructor(node: Node, config: Config) {
     this._config = config
     this._node = node
     this._logger = config.logger