client: protocol type improvements

Author: holgerd77

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events'
-import { Protocol } from '../protocol/protocol'
+import { Message, Protocol } from '../protocol/protocol'
 import { Peer } from '../peer/peer'
 import { Sender } from './sender'
 import { Config } from '../../config'
@@ -31,7 +31,7 @@ export class BoundProtocol extends EventEmitter {
   private versions: number[]
   private timeout: number
   private _status: any
-  private resolvers: Map<string, any>
+  private resolvers: Map<string | number, any>
 
   /**
    * Create bound protocol
@@ -80,9 +80,9 @@ export class BoundProtocol extends EventEmitter {
    * @param  {Object} message message object
    * @emits  message
    */
-  handle(incoming: any) {
+  handle(incoming: Message) {
     const messages = this.protocol.messages
-    const message = messages.find((m: any) => m.code === incoming.code)
+    const message = messages.find((m) => m.code === incoming.code)
     if (!message) {
       return
     }
@@ -117,16 +117,16 @@ export class BoundProtocol extends EventEmitter {
    * @param  name message name
    * @param  args message arguments
    */
-  send(name: string, args?: any): any {
+  send(name: string, args?: any) {
     const messages = this.protocol.messages
-    const message = messages.find((m: any) => m.name === name)
+    const message = messages.find((m) => m.name === name)
     if (message) {
       const encoded = this.protocol.encode(message, args)
       this.sender.sendMessage(message.code, encoded)
-      return message
     } else {
       throw new Error(`Unknown message: ${name}`)
     }
+    return message
   }
 
   /**
@@ -143,14 +143,14 @@ export class BoundProtocol extends EventEmitter {
       resolve: null,
       reject: null,
     }
-    if (this.resolvers.get(message.response)) {
+    if (this.resolvers.get(message.response!)) {
       throw new Error(`Only one active request allowed per message type (${name})`)
     }
-    this.resolvers.set(message.response, resolver)
+    this.resolvers.set(message.response!, resolver)
     return new Promise((resolve, reject) => {
       resolver.timeout = setTimeout(() => {
         resolver.timeout = null
-        this.resolvers.delete(message.response)
+        this.resolvers.delete(message.response!)
         reject(new Error(`Request timed out after ${this.timeout}ms`))
       }, this.timeout)
       resolver.resolve = resolve
@@ -163,9 +163,9 @@ export class BoundProtocol extends EventEmitter {
    * corresponding response message.
    */
   addMethods() {
-    const messages = this.protocol.messages.filter((m: any) => m.response)
+    const messages = this.protocol.messages.filter((m) => m.response)
     for (const message of messages) {
-      const name = message.name as string
+      const name = message.name
       const camel = name[0].toLowerCase() + name.slice(1)
       ;(this as any)[camel] = async (args: any[]) =>
         this.request(name, args).catch((error: Error) => {

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

@@ -130,7 +130,7 @@ export class LesProtocol extends Protocol {
    * Messages defined by this protocol
    * @type {Protocol~Message[]}
    */
-  get messages(): any {
+  get messages(): Message[] {
     return messages
   }
 
@@ -161,8 +161,8 @@ export class LesProtocol extends Protocol {
         txRelay: 1,
         'flowControl/BL': new BN(this.flow.bl).toArrayLike(Buffer),
         'flowControl/MRR': new BN(this.flow.mrr).toArrayLike(Buffer),
-        'flowControl/MRC': Object.entries(this.flow.mrc).map(([name, { base, req }]: any) => {
-          const { code }: any = messages.find((m) => m.name === name)
+        'flowControl/MRC': Object.entries(this.flow.mrc).map(([name, { base, req }]) => {
+          const { code } = messages.find((m) => m.name === name)!
           return [code, base, req]
         }),
       }

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

@@ -14,6 +14,7 @@ export interface ProtocolOptions {
 export type Message = {
   name: string
   code: number
+  payload?: any
   // TODO: check semantics of this field
   response?: number
   // TODO: check if this should be optional

packages/client/test/integration/fullethereumservice.spec.ts

@@ -34,7 +34,7 @@ tape('[Integration:FullEthereumService]', async (t) => {
     t.ok(headers![1].hash().equals(hash), 'handled GetBlockHeaders')
     const bodies = await peer.eth!.getBlockBodies([hash])
     t.deepEquals(bodies, [[[], []]], 'handled GetBlockBodies')
-    await peer.eth!.send('NewBlockHashes', [[hash, new BN(2)]])
+    peer.eth!.send('NewBlockHashes', [[hash, new BN(2)]])
     t.pass('handled NewBlockHashes')
     await destroy(server, service)
     t.end()

packages/client/test/net/protocol/boundprotocol.spec.ts

@@ -76,17 +76,16 @@ tape('[BoundProtocol]', (t) => {
       peer,
       sender,
     })
-    t.notOk(bound.handle({}), 'missing message.code')
     bound.once('error', (err: any) => {
       t.ok(/error0/.test(err.message), 'decode error')
     })
     td.when(protocol.decode(testMessage, '1')).thenThrow(new Error('error0'))
-    bound.handle({ code: 0x01, payload: '1' })
+    bound.handle({ name: 'TestMessage', code: 0x01, payload: '1' })
     bound.once('message', (message: any) => {
       t.deepEquals(message, { name: 'TestMessage', data: 2 }, 'correct message')
     })
     td.when(protocol.decode(testMessage, '2')).thenReturn(2)
-    bound.handle({ code: 0x01, payload: '2' })
+    bound.handle({ name: 'TestMessage', code: 0x01, payload: '2' })
     t.end()
   })