Merge pull request #1019 from ethereumjs/client-fix-undefined-result

client: fix undefined BlockHeaders value when syncing

Author: holgerd77

package-lock.json

@@ -99,15 +99,14 @@ export class Peer extends events.EventEmitter {
    * @param  {Sender}    sender Sender instance provided by subclass
    * @return {Promise}
    * @example
-   *
    * await peer.bindProtocol(ethProtocol, sender)
    * // Example: Directly call message name as a method on the bound protocol
-   * const headers1 = await peer.eth.getBlockHeaders(1, 100, 0, 0)
+   * const headers1 = await peer.eth.getBlockHeaders({ block: new BN(1), max: 100 })
    * // Example: Call request() method with message name as first parameter
-   * const headers2 = await peer.eth.request('getBlockHeaders', 1, 100, 0, 0)
+   * const headers2 = await peer.eth.request('getBlockHeaders', { block: new BN(1), max: 100 })
    * // Example: Call send() method with message name as first parameter and
    * // wait for response message as an event
-   * peer.eth.send('getBlockHeaders', 1, 100, 0, 0)
+   * peer.eth.send('getBlockHeaders', { block: new BN(1), max: 100 })
    * peer.eth.on('message', ({ data }) => console.log(`Received ${data.length} headers`))
    */
   async bindProtocol(protocol: Protocol, sender: Sender): Promise<void> {

packages/client/lib/net/peer/peer.ts

@@ -1,12 +1,11 @@
 import { randomBytes } from 'crypto'
 import {
   Capabilities as Devp2pCapabilities,
-  DPT as Devp2pDPT,
   ETH as Devp2pETH,
   LES as Devp2pLES,
   Peer as Devp2pRlpxPeer,
   RLPx as Devp2pRLPx,
-} from 'ethereumjs-devp2p'
+} from '@ethereumjs/devp2p'
 import { Protocol, RlpxSender } from '../protocol'
 import { Peer, PeerOptions } from './peer'
 
@@ -103,9 +102,7 @@ export class RlpxPeer extends Peer {
     await Promise.all(this.protocols.map((p) => p.open()))
     this.rlpx = new Devp2pRLPx(key, {
       capabilities: RlpxPeer.capabilities(this.protocols),
-      listenPort: null,
-      dpt: (<unknown>null) as Devp2pDPT, // TODO: required option
-      maxPeers: (<unknown>null) as number, // TODO: required option
+      common: this.config.common,
     })
     await this.rlpx.connect({
       id: Buffer.from(this.id, 'hex'),

packages/client/lib/net/peer/rlpxpeer.ts

@@ -170,6 +170,7 @@ export class BoundProtocol extends EventEmitter {
       ;(this as any)[camel] = async (args: any[]) =>
         this.request(name, args).catch((error: Error) => {
           this.emit('error', error)
+          return []
         })
     }
   }

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

@@ -8,14 +8,22 @@ interface EthProtocolOptions extends ProtocolOptions {
   chain: Chain
 }
 
-/* Messages with responses that are added as methods in camelCase to BoundProtocol. */
+type GetBlockHeadersOpts = {
+  /* The block's number or hash */
+  block: BN | Buffer
+  /* Max number of blocks to return */
+  max: number
+  /* Number of blocks to skip apart (default: 0) */
+  skip?: number
+  /* Fetch blocks in reverse (default: false) */
+  reverse?: boolean
+}
+/*
+ * Messages with responses that are added as
+ * methods in camelCase to BoundProtocol.
+ */
 export interface EthProtocolMethods {
-  getBlockHeaders: (opts: {
-    block: BN | Buffer
-    max: number
-    skip?: number
-    reverse?: number
-  }) => Promise<BlockHeader[]>
+  getBlockHeaders: (opts: GetBlockHeadersOpts) => Promise<BlockHeader[]>
   getBlockBodies: (hashes: Buffer[]) => Promise<Block[]>
 }
 
@@ -30,17 +38,17 @@ const messages: Message[] = [
     name: 'GetBlockHeaders',
     code: 0x03,
     response: 0x04,
-    encode: ({ block, max, skip = 0, reverse = 0 }: any) => [
+    encode: ({ block, max, skip = 0, reverse = false }: GetBlockHeadersOpts) => [
       BN.isBN(block) ? block.toArrayLike(Buffer) : block,
       max,
       skip,
-      reverse,
+      !reverse ? 0 : 1,
     ],
     decode: ([block, max, skip, reverse]: any) => ({
       block: block.length === 32 ? block : new BN(block),
       max: bufferToInt(max),
       skip: bufferToInt(skip),
-      reverse: bufferToInt(reverse),
+      reverse: bufferToInt(reverse) === 0 ? false : true,
     }),
   },
   {

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

@@ -12,15 +12,26 @@ export interface LesProtocolOptions extends ProtocolOptions {
   flow?: FlowControl
 }
 
-/* Messages with responses that are added as methods in camelCase to BoundProtocol. */
+type GetBlockHeadersOpts = {
+  /* Request id (default: next internal id) */
+  reqId?: BN
+  /* The block's number or hash */
+  block: BN | Buffer
+  /* Max number of blocks to return */
+  max: number
+  /* Number of blocks to skip apart (default: 0) */
+  skip?: number
+  /* Fetch blocks in reverse (default: false) */
+  reverse?: boolean
+}
+/*
+ * Messages with responses that are added as
+ * methods in camelCase to BoundProtocol.
+ */
 export interface LesProtocolMethods {
-  getBlockHeaders: (opts: {
-    reqId?: BN
-    block: BN | Buffer
-    max: number
-    skip?: number
-    reverse?: number
-  }) => Promise<{ reqId: BN; bv: BN; headers: BlockHeader[] }>
+  getBlockHeaders: (
+    opts: GetBlockHeadersOpts
+  ) => Promise<{ reqId: BN; bv: BN; headers: BlockHeader[] }>
 }
 
 const id = new BN(0)
@@ -48,16 +59,16 @@ const messages: Message[] = [
     name: 'GetBlockHeaders',
     code: 0x02,
     response: 0x03,
-    encode: ({ reqId, block, max, skip = 0, reverse = 0 }: any) => [
+    encode: ({ reqId, block, max, skip = 0, reverse = false }: GetBlockHeadersOpts) => [
       (reqId === undefined ? id.iaddn(1) : new BN(reqId)).toArrayLike(Buffer),
-      [BN.isBN(block) ? block.toArrayLike(Buffer) : block, max, skip, reverse],
+      [BN.isBN(block) ? block.toArrayLike(Buffer) : block, max, skip, !reverse ? 0 : 1],
     ],
     decode: ([reqId, [block, max, skip, reverse]]: any) => ({
       reqId: new BN(reqId),
       block: block.length === 32 ? block : new BN(block),
       max: bufferToInt(max),
       skip: bufferToInt(skip),
-      reverse: bufferToInt(reverse),
+      reverse: bufferToInt(reverse) === 0 ? false : true,
     }),
   },
   {

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

@@ -1,5 +1,5 @@
 import { randomBytes } from 'crypto'
-import { RLPx as Devp2pRLPx, Peer as Devp2pRLPxPeer, DPT as Devp2pDPT } from 'ethereumjs-devp2p'
+import { RLPx as Devp2pRLPx, Peer as Devp2pRLPxPeer, DPT as Devp2pDPT } from '@ethereumjs/devp2p'
 import { RlpxPeer } from '../peer/rlpxpeer'
 import { Server, ServerOptions } from './server'
 
@@ -212,6 +212,7 @@ export class RlpxServer extends Server {
       capabilities: RlpxPeer.capabilities(Array.from(this.protocols)),
       remoteClientIdFilter: this.clientFilter,
       listenPort: this.port,
+      common: this.config.common,
     })
 
     this.rlpx.on('peer:added', async (rlpxPeer: Devp2pRLPxPeer) => {

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

@@ -2,6 +2,7 @@ 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 {
@@ -58,13 +59,16 @@ export class BlockFetcher extends Fetcher {
 
   /**
    * Requests blocks associated with this job
-   * @param  job
+   * @param job
    */
   async request(job: any): Promise<any> {
     const { task, peer } = job
     const { first, count } = task
-    const headers = await peer.eth.getBlockHeaders({ block: first, max: count })
-    const bodies = await peer.eth.getBlockBodies(headers.map((h: any) => h.hash()))
+    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) =>
       Block.fromValuesArray([headers[i].raw(), txsData, unclesData], { common: this.config.common })
     )

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

@@ -1,6 +1,6 @@
 import { BlockFetcher, BlockFetcherOptions } from './blockfetcher'
 import { Peer } from '../../net/peer'
-import { FlowControl } from '../../net/protocol'
+import { FlowControl, LesProtocolMethods } from '../../net/protocol'
 
 export interface HeaderFetcherOptions extends BlockFetcherOptions {
   /* Flow control manager */
@@ -26,16 +26,15 @@ export class HeaderFetcher extends BlockFetcher {
 
   /**
    * Requests block headers for the given task
-   * @param  job
-   * @return {Promise}
+   * @param job
    */
-  async request(job: any): Promise<any[] | boolean> {
+  async request(job: any) {
     const { task, peer } = job
     if (this.flow.maxRequestCount(peer, 'GetBlockHeaders') < this.maxPerRequest) {
       // we reached our request limit. try with a different peer.
       return false
     }
-    return peer.les.getBlockHeaders({ block: task.first, max: task.count })
+    return (peer.les as LesProtocolMethods).getBlockHeaders({ block: task.first, max: task.count })
   }
 
   /**

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

@@ -54,10 +54,10 @@
     "@ethereumjs/block": "^3.0.0",
     "@ethereumjs/blockchain": "^5.0.0",
     "@ethereumjs/common": "^2.0.0",
+    "@ethereumjs/devp2p": "^3.0.3",
     "@ethereumjs/trie": "^4.0.0",
     "@ethereumjs/vm": "^5.0.0",
     "chalk": "^2.4.2",
-    "ethereumjs-devp2p": "^3.0.3",
     "ethereumjs-util": "^7.0.7",
     "fs-extra": "^7.0.1",
     "jayson": "^3.3.4",