Type options

Author: ryanio

bin/cli.ts

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 
-const chains = require('@ethereumjs/common/dist/chains').chains
+import { Server as RPCServer } from 'jayson'
+import Common from '@ethereumjs/common'
 import { parseParams } from '../lib/util'
 import Node from '../lib/node'
-import { Server as RPCServer } from 'jayson'
 import { Config } from '../lib/config'
-import Common from '@ethereumjs/common'
+import { Logger } from '../lib/logging'
 import { RPCManager } from '../lib/rpc'
-import { Logger } from 'winston'
 const level = require('level')
 const path = require('path')
 const fs = require('fs-extra')
+const chains = require('@ethereumjs/common/dist/chains').chains
 
 const networks = Object.entries(chains.names)
 

lib/blockchain/chain.ts

@@ -12,7 +12,7 @@ export interface ChainOptions {
   /**
    * Client configuration instance
    */
-  config: Config
+  config?: Config
 
   /**
    * Database to store blocks and metadata. Should be an abstract-leveldown compliant store.
@@ -79,7 +79,7 @@ export interface GenesisBlockParams {
 export class Chain extends EventEmitter {
   public config: Config
 
-  public db: any
+  public db: LevelUp
   public blockchain: Blockchain
   public opened: boolean
 
@@ -99,18 +99,18 @@ export class Chain extends EventEmitter {
    * Create new chain
    * @param {ChainOptions} options
    */
-  constructor(options: ChainOptions) {
+  constructor(options: ChainOptions = {}) {
     super()
 
-    this.config = options.config
+    this.config = options.config ?? new Config()
 
     this.blockchain =
       options.blockchain ??
       new Blockchain({
         db: options.db,
+        common: this.config.common,
         validateBlocks: false,
         validatePow: false,
-        common: this.config.common,
       })
 
     this.db = this.blockchain.db
@@ -249,8 +249,7 @@ export class Chain extends EventEmitter {
 
   /**
    * Insert new blocks into blockchain
-   * @param  {Block[]}       blocks list of blocks to add
-   * @return {Promise<void>}
+   * @param {Block[]} blocks list of blocks to add
    */
   async putBlocks(blocks: Block[]): Promise<void> {
     if (blocks.length === 0) {

lib/config.ts

@@ -1,82 +1,93 @@
 const os = require('os')
 import Common from '@ethereumjs/common'
-import { Logger } from 'winston'
-import { defaultLogger, getLogger } from './logging'
+import { getLogger, Logger } from './logging'
 import { Libp2pServer, RlpxServer } from './net/server'
 import { parseTransports } from './util'
 
-export interface Options {
+export interface ConfigOptions {
   /**
    * Specify the chain and hardfork by passing a Common instance.
    *
    * Default: chain 'mainnet' and hardfork 'chainstart'
    */
   common?: Common
+
   /**
    * Synchronization mode ('fast' or 'light')
    *
    * Default: 'fast'
    */
   syncmode?: string
+
   /**
    * Serve light peer requests
    *
    * Default: `false`
    */
   lightserv?: boolean
+
   /**
    * Root data directory for the blockchain
    */
   datadir?: string
+
   /**
    * Network transports ('rlpx' and/or 'libp2p')
    *
    * Default: `['rlpx:port=30303', 'libp2p']`
    */
   transports?: string[]
+
   /**
    * Transport servers (RLPx or Libp2p)
    * Use `transports` option, only used for testing purposes
    *
    * 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
+
   /**
    * Logging verbosity
    *
    * Choices: ['error', 'warn', 'info', 'debug']
    * Default: 'info'
    */
   loglevel?: string
+
   /**
    * A custom winston logger can be provided
    * if setting logging verbosity is not sufficient
    *
    * Default: Logger with loglevel 'info'
    */
   logger?: Logger
+
   /**
    * Number of peers needed before syncing
    *
    * Default: `2`
    */
   minPeers?: number
+
   /**
    * Maximum peers allowed
    *
@@ -116,7 +127,7 @@ export class Config {
 
   public readonly servers: (RlpxServer | Libp2pServer)[] = []
 
-  constructor(options: Options = {}) {
+  constructor(options: ConfigOptions = {}) {
     // TODO: map chainParams (and lib/util.parseParams) to new Common format
     this.common = options.common ?? Config.COMMON_DEFAULT
     this.syncmode = options.syncmode ?? Config.SYNCMODE_DEFAULT
@@ -138,16 +149,7 @@ export class Config {
       // Logger option takes precedence
       this.logger = options.logger
     } else {
-      // Use the default logger to keep the logger deactivation in the test working
-      // along these lines in the test files
-      // import { defaultLogger } from '../../lib/logging'
-      // defaultLogger.silent = true
-      // TODO: find a more generic solution here
-      if (this.loglevel === 'info') {
-        this.logger = defaultLogger
-      } else {
-        this.logger = getLogger({ loglevel: this.loglevel })
-      }
+      this.logger = getLogger({ loglevel: this.loglevel })
     }
 
     if (options.servers) {

lib/logging.ts

@@ -1,7 +1,9 @@
 import chalk from 'chalk'
-import { createLogger, format, transports } from 'winston'
+import { createLogger, format, transports, Logger as WinstonLogger } from 'winston'
 const { combine, timestamp, label, printf } = format
 
+export type Logger = WinstonLogger
+
 const levelColors: any = {
   error: 'red',
   warn: 'yellow',

lib/net/peer/libp2ppeer.ts

@@ -1,23 +1,24 @@
-import { Peer } from './peer'
 import PeerId from 'peer-id'
 import PeerInfo from 'peer-info'
-import { Libp2pNode } from './libp2pnode'
+import { Multiaddrs, MultiaddrsLike } from '../../types'
+import { parseMultiaddrs } from '../../util'
 import { Libp2pSender } from '../protocol/libp2psender'
+import { Peer, PeerOptions } from './peer'
+import { Libp2pNode } from './libp2pnode'
 
-const defaultOptions = {
-  multiaddrs: ['/ip4/0.0.0.0/tcp/0'],
-  key: null,
-  bootnodes: [],
+export interface Libp2pPeerOptions extends Omit<PeerOptions, 'address' | 'transport'> {
+  /* Multiaddrs to listen on (can be a comma separated string or list) */
+  multiaddrs?: MultiaddrsLike
 }
 
 /**
  * Libp2p peer
  * @memberof module:net/peer
  * @example
  *
- * const { Libp2pPeer } = require('./lib/net/peer')
+ * import { Libp2pPeer } from './lib/net/peer'
  * import { Chain } from './lib/blockchain'
- * const { EthProtocol } = require('./lib/net/protocol')
+ * import { EthProtocol } from './lib/net/protocol'
  *
  * const chain = new Chain()
  * const protocols = [ new EthProtocol({ chain })]
@@ -31,31 +32,22 @@ const defaultOptions = {
  *   .connect()
  */
 export class Libp2pPeer extends Peer {
-  private multiaddrs: string | string[]
+  private multiaddrs: Multiaddrs
   private connected: boolean
 
   /**
    * Create new libp2p peer
-   * @param {Object}      options constructor parameters
-   * @param {string}      options.id peer id
-   * @param {multiaddr[]} options.multiaddrs multiaddrs to listen on (can be
-   * a comma separated string or list)
-   * @param {Protocols[]} [options.protocols=[]] supported protocols
+   * @param {Libp2pPeerOptions}
    */
-  constructor(options: any) {
-    super({ ...options, transport: 'libp2p' })
-    options = { ...defaultOptions, ...options }
+  constructor(options: Libp2pPeerOptions = {}) {
+    options.multiaddrs = options.multiaddrs
+      ? parseMultiaddrs(options.multiaddrs)
+      : ['/ip4/0.0.0.0/tcp/0']
+
+    super({ ...options, transport: 'libp2p', address: options.multiaddrs[0] })
 
     this.multiaddrs = options.multiaddrs
-    this.server = null
     this.connected = false
-    this.init()
-  }
-
-  init() {
-    if (typeof this.multiaddrs === 'string') {
-      this.multiaddrs = this.multiaddrs.split(',')
-    }
     this.address = this.multiaddrs.map((ma: string) => ma.split('/ipfs')[0]).join(',')
   }
 

lib/net/peer/peer.ts

@@ -1,12 +1,29 @@
 import * as events from 'events'
-import { Protocol } from '../protocol/protocol'
-import { BoundProtocol, Sender } from '../protocol'
+import { Protocol, BoundProtocol, Sender } from '../protocol'
+import { Server } from '../server'
 import { Config } from '../../config'
 
-const defaultOptions = {
-  inbound: false,
-  server: null,
-  protocols: [],
+export interface PeerOptions {
+  /* Config */
+  config?: Config
+
+  /* Peer id */
+  id?: string
+
+  /* Peer address */
+  address: string
+
+  /* Transport name */
+  transport: string
+
+  /* Pass true if peer initiated connection (default: false) */
+  inbound?: boolean
+
+  /* Supported protocols */
+  protocols?: Protocol[]
+
+  /* Server */
+  server?: Server
 }
 
 /**
@@ -15,42 +32,34 @@ const defaultOptions = {
  */
 export class Peer extends events.EventEmitter {
   public config: Config
-
   public id: string
-  protected transport: string
-  protected protocols: any[]
-  private _idle: boolean
   public address: string
   public inbound: boolean
-  public bound: Map<string, any>
-  public server: any
+  public server: Server | undefined
+  public bound: Map<string, BoundProtocol>
+  protected transport: string
+  protected protocols: Protocol[]
+  private _idle: boolean
 
   // Dynamically bound protocol properties
   public les: BoundProtocol | undefined
   public eth: BoundProtocol | undefined
 
   /**
    * Create new peer
-   * @param {Object}      options constructor parameters
-   * @param {string}      options.id peer id
-   * @param {string}      [options.address] peer address
-   * @param {boolean}     [options.inbound] true if peer initiated connection
-   * @param {string}      [options.transport] transport name
-   * @param {Protocols[]} [options.protocols=[]] supported protocols
+   * @param {PeerOptions}
    */
-  constructor(options: any) {
+  constructor(options: PeerOptions) {
     super()
 
-    options = { ...defaultOptions, ...options }
-    this.config = options.config
+    this.config = options.config ?? new Config()
 
-    this.id = options.id
+    this.id = options.id ?? ''
     this.address = options.address
-    this.inbound = options.inbound
     this.transport = options.transport
-    this.protocols = options.protocols
+    this.inbound = options.inbound ?? false
+    this.protocols = options.protocols ?? []
     this.bound = new Map()
-    this.server = options.server
 
     this._idle = true
   }