Merge branch 'master' into eip-2565

Author: holgerd77

package-lock.json

@@ -1,7 +1,8 @@
 import { BN, bufferToInt } from 'ethereumjs-util'
-import { Block, BlockHeader, BlockHeaderBuffer } from '@ethereumjs/block'
+import { BlockHeader, BlockHeaderBuffer } from '@ethereumjs/block'
 import { Chain } from './../../blockchain'
 import { Message, Protocol, ProtocolOptions } from './protocol'
+import { BlockBodyBuffer } from '@ethereumjs/block'
 
 interface EthProtocolOptions extends ProtocolOptions {
   /* Blockchain */
@@ -24,7 +25,7 @@ type GetBlockHeadersOpts = {
  */
 export interface EthProtocolMethods {
   getBlockHeaders: (opts: GetBlockHeadersOpts) => Promise<BlockHeader[]>
-  getBlockBodies: (hashes: Buffer[]) => Promise<Block[]>
+  getBlockBodies: (hashes: Buffer[]) => Promise<BlockBodyBuffer[]>
 }
 
 const messages: Message[] = [

packages/client/lib/net/protocol/ethprotocol.ts

@@ -122,17 +122,17 @@ export class RlpxServer extends Server {
   async bootstrap(): Promise<void> {
     const promises = this.bootnodes.map((node) => {
       const bootnode = {
-        address: node.ip,
+        address: node.ip!,
         udpPort: node.port,
         tcpPort: node.port,
       }
-      try {
-        return this.dpt!.bootstrap(bootnode)
-      } catch (e) {
-        this.error(e)
-      }
+      return this.dpt!.bootstrap(bootnode)
     })
-    await Promise.all(promises)
+    try {
+      await Promise.all(promises)
+    } catch (e) {
+      this.error(e)
+    }
   }
 
   /**

packages/client/lib/net/server/rlpxserver.ts

@@ -35,18 +35,18 @@ export class Admin {
    * @param {*} [params] An empty array
    * @param {*} [cb] A function with an error object as the first argument and the result as the second
    */
-  async nodeInfo(params: any, cb: Function) {
+  async nodeInfo(params: [], cb: Function) {
     const rlpxInfo = (this._client.server('rlpx') as RlpxServer).getRlpxInfo()
     const { enode, id, ip, listenAddr, ports } = rlpxInfo
     const { discovery, listener } = ports
     const clientName = getClientVersion()
 
     // TODO version not present in reference..
     // const ethVersion = Math.max.apply(Math, this._ethProtocol.versions)
-    const latestHeader = (this._chain as any)._headers.latest
-    const difficulty = latestHeader?.difficulty ?? 0 // should be number
+    const latestHeader = await this._chain.getLatestHeader()
+    const difficulty = latestHeader.difficulty
     const genesis = bufferToHex(this._chain.genesis.hash)
-    const head = bufferToHex(latestHeader?.mixHash ?? null)
+    const head = bufferToHex(latestHeader.mixHash)
     const network = this._chain.networkId
 
     const nodeInfo = {

packages/client/lib/rpc/modules/admin.ts

@@ -1,24 +1,25 @@
 import { Chain } from '../../blockchain'
 import { middleware, validators } from '../validation'
 import { toBuffer, stripHexPrefix, BN } from 'ethereumjs-util'
+import { EthereumClient } from '../..'
 
 /**
  * eth_* RPC module
  * @memberof module:rpc/modules
  */
 export class Eth {
   private _chain: Chain
-  public ethVersion: any
+  public ethVersion: number
 
   /**
    * Create eth_* RPC module
    * @param {Node} Node to which the module binds
    */
-  constructor(node: any) {
+  constructor(node: EthereumClient) {
     const service = node.services.find((s: any) => s.name === 'eth')
-    this._chain = service.chain
-    const ethProtocol = service.protocols.find((p: any) => p.name === 'eth')
-    this.ethVersion = Math.max.apply(Math, ethProtocol.versions)
+    this._chain = service!.chain
+    const ethProtocol = service!.protocols.find((p: any) => p.name === 'eth')
+    this.ethVersion = Math.max.apply(Math, ethProtocol!.versions)
 
     this.blockNumber = middleware(this.blockNumber.bind(this), 0)
 

packages/client/lib/rpc/modules/eth.ts

@@ -1,6 +1,7 @@
 import { EthereumService } from '../../service/ethereumservice'
 import { middleware } from '../validation'
 import { addHexPrefix } from 'ethereumjs-util'
+import { EthereumClient } from '../..'
 
 /**
  * net_* RPC module
@@ -15,8 +16,8 @@ export class Net {
    * Create net_* RPC module
    * @param {Node} Node to which the module binds
    */
-  constructor(node: any) {
-    const service: EthereumService = node.services.find((s: any) => s.name === 'eth')
+  constructor(node: EthereumClient) {
+    const service: EthereumService = node.services.find((s: any) => s.name === 'eth')!
     this._chain = service.chain
     this._node = node
     this._peerPool = service.pool

packages/client/lib/rpc/modules/net.ts

@@ -1,21 +1,23 @@
 import { middleware, validators } from '../validation'
 import { addHexPrefix, keccak, toBuffer } from 'ethereumjs-util'
 import { getClientVersion } from '../../util'
+import { EthereumClient } from '../..'
+import { Chain } from '../../blockchain'
 
 /**
  * web3_* RPC module
  * @memberof module:rpc/modules
  */
 export class Web3 {
-  private _chain: any
+  private _chain?: Chain
 
   /**
    * Create web3_* RPC module
    * @param {Node} Node to which the module binds
    */
-  constructor(node: any) {
+  constructor(node: EthereumClient) {
     const service = node.services.find((s: any) => s.name === 'eth')
-    this._chain = service.chain
+    this._chain = service?.chain
 
     this.clientVersion = middleware(this.clientVersion.bind(this), 0, [])
 

packages/client/lib/rpc/modules/web3.ts

@@ -11,11 +11,11 @@ export interface EthereumServiceOptions extends ServiceOptions {
   /* Blockchain database */
   db?: LevelUp
 
-  /* Protocol timeout in ms (default: 8000) */
-  timeout?: number
-
-  /* Sync retry interval in ms (default: 1000) */
+  /* Sync retry interval in ms (default: 8000) */
   interval?: number
+
+  /* Protocol timeout in ms (default: 2000) */
+  timeout?: number
 }
 
 /**
@@ -39,7 +39,7 @@ export class EthereumService extends Service {
     this.flow = new FlowControl()
     this.chain = options.chain ?? new Chain(options)
     this.interval = options.interval ?? 8000
-    this.timeout = options.timeout ?? 1000
+    this.timeout = options.timeout ?? 2000
   }
 
   /**

packages/client/lib/service/ethereumservice.ts

@@ -1,51 +1,30 @@
-import { Fetcher, FetcherOptions } from './fetcher'
 import { Block, BlockBodyBuffer } from '@ethereumjs/block'
-import { BN } from 'ethereumjs-util'
 import { Peer } from '../../net/peer'
 import { EthProtocolMethods } from '../../net/protocol'
-import { Chain } from '../../blockchain'
-
-export interface BlockFetcherOptions extends FetcherOptions {
-  /* Blockchain */
-  chain: Chain
-
-  /* Block number to start fetching from */
-  first: BN
-
-  /* How many blocks to fetch */
-  count: BN
-}
+import { Job } from './types'
+import { BlockFetcherBase, JobTask, BlockFetcherOptions } from './blockfetcherbase'
 
 /**
  * Implements an eth/62 based block fetcher
  * @memberof module:sync/fetcher
  */
-export class BlockFetcher extends Fetcher {
-  protected chain: Chain
-  protected first: BN
-  protected count: BN
-
+export class BlockFetcher extends BlockFetcherBase<Block[], Block> {
   /**
    * Create new block fetcher
    * @param {BlockFetcherOptions}
    */
   constructor(options: BlockFetcherOptions) {
     super(options)
-
-    this.chain = options.chain
-    this.maxPerRequest = options.maxPerRequest ?? 128
-    this.first = options.first
-    this.count = options.count
   }
 
   /**
    * Generate list of tasks to fetch
    * @return {Object[]} tasks
    */
-  tasks(): object[] {
+  tasks(): JobTask[] {
     const { first, count } = this
     const max = this.maxPerRequest
-    const tasks = []
+    const tasks: JobTask[] = []
     while (count.gten(max)) {
       tasks.push({ first: first.clone(), count: max })
       first.iaddn(max)
@@ -61,18 +40,20 @@ export class BlockFetcher extends Fetcher {
    * Requests blocks associated with this job
    * @param job
    */
-  async request(job: any): Promise<any> {
+  async request(job: Job<JobTask, Block[], Block>): Promise<Block[]> {
     const { task, peer } = job
     const { first, count } = task
-    const headers = await (peer.eth as EthProtocolMethods).getBlockHeaders({
+    const headers = await (peer!.eth as EthProtocolMethods).getBlockHeaders({
       block: first,
       max: count,
     })
-    const bodies = await peer.eth.getBlockBodies(headers.map((h) => h.hash()))
-    const blocks = bodies.map(([txsData, unclesData]: BlockBodyBuffer, i: number) =>
+    const bodies: BlockBodyBuffer[] = <BlockBodyBuffer[]>(
+      await peer!.eth!.getBlockBodies(headers.map((h) => h.hash()))
+    )
+    const blocks: Block[] = bodies.map(([txsData, unclesData]: BlockBodyBuffer, i: number) =>
       Block.fromValuesArray([headers[i].raw(), txsData, unclesData], { common: this.config.common })
     )
-    return { blocks }
+    return blocks
   }
 
   /**
@@ -81,18 +62,20 @@ export class BlockFetcher extends Fetcher {
    * @param  result fetch result
    * @return {*} results of processing job or undefined if job not finished
    */
-  process(job: any, result: any) {
-    if (result.blocks && result.blocks.length === job.task.count) {
-      return result.blocks
+  process(job: Job<JobTask, Block[], Block>, result: Block[]) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (result && result.length === job.task.count) {
+      return result
     }
+    return
   }
 
   /**
    * Store fetch result. Resolves once store operation is complete.
    * @param {Block[]} blocks fetch result
    * @return {Promise}
    */
-  async store(blocks: Array<any>) {
+  async store(blocks: Block[]) {
     await this.chain.putBlocks(blocks)
   }
 
@@ -102,7 +85,7 @@ export class BlockFetcher extends Fetcher {
    * @return {Peer}
    */
   // TODO: find out what _job is supposed to be doing here...
-  peer(_job: any): Peer {
+  peer(): Peer {
     return this.pool.idle((p: any) => p.eth)
   }
 }

packages/client/lib/sync/fetcher/blockfetcher.ts

@@ -0,0 +1,61 @@
+import { Fetcher, FetcherOptions } from './fetcher'
+import { BN } from 'ethereumjs-util'
+import { Chain } from '../../blockchain'
+
+export interface BlockFetcherOptions extends FetcherOptions {
+  /* Blockchain */
+  chain: Chain
+
+  /* Block number to start fetching from */
+  first: BN
+
+  /* How many blocks to fetch */
+  count: BN
+}
+
+export type JobTask = {
+  first: BN
+  count: number
+}
+
+export abstract class BlockFetcherBase<JobResult, StorageItem> extends Fetcher<
+  JobTask,
+  JobResult,
+  StorageItem
+> {
+  protected chain: Chain
+  protected first: BN
+  protected count: BN
+
+  /**
+   * Create new block fetcher
+   * @param {BlockFetcherOptions}
+   */
+  constructor(options: BlockFetcherOptions) {
+    super(options)
+
+    this.chain = options.chain
+    this.maxPerRequest = options.maxPerRequest ?? 128
+    this.first = options.first
+    this.count = options.count
+  }
+
+  /**
+   * Generate list of tasks to fetch
+   * @return {Object[]} tasks
+   */
+  tasks(): JobTask[] {
+    const { first, count } = this
+    const max = this.maxPerRequest
+    const tasks: JobTask[] = []
+    while (count.gten(max)) {
+      tasks.push({ first: first.clone(), count: max })
+      first.iaddn(max)
+      count.isubn(max)
+    }
+    if (count.gtn(0)) {
+      tasks.push({ first: first.clone(), count: count.toNumber() })
+    }
+    return tasks
+  }
+}