[WIP] ETH2.0 Wire protocol

package.json

@@ -62,6 +62,7 @@
     "pouchdb-adapter-memory": "^7.0.0",
     "pouchdb-core": "^7.0.0",
     "promisify-es6": "^1.0.3",
+    "pull-stream": "^3.6.10",
     "winston": "^3.2.1",
     "ws": "^6.2.1"
   },

src/node/index.ts

@@ -52,7 +52,7 @@ class BeaconNode {
     );
 
     this.db = new LevelDB(this.conf.db);
-    this.network = new P2PNetwork(this.conf.network);
+    this.network = new P2PNetwork(this.conf.network, {chain, db});
     this.eth1 = new EthersEth1Notifier(
       this.conf.eth1,
       {

src/p2p/index.ts

@@ -4,9 +4,13 @@ import {LodestarNode} from "./node";
 import logger, {AbstractLogger} from "../logger";
 import {PeerInfo} from "peer-info";
 import LibP2p from "libp2p";
+import {pull} from "pull-stream";
 import {PeerBook} from "peer-book";
 import {PeerId} from "peer-id";
 import {promisify} from "promisify-es6";
+import {Hello, Goodbye} from "../rpc/api/wire/messages";
+import {DB} from "../db";
+import {BeaconChain} from "../chain"
 
 export interface P2pOptions {
   maxPeers: number;
@@ -41,15 +45,21 @@ export class P2PNetwork extends EventEmitter implements Service {
 
   private log: AbstractLogger;
 
-  public constructor(opts: P2pOptions) {
+  private chain: BeaconChain;
+
+  private db: DB;
+
+  public constructor(opts: P2pOptions, {chain, db}) {
     super();
     this.options = opts;
     this.maxPeers = this.options.maxPeers;
     this.refreshInterval = this.options.refreshInterval;
     this.peerBook = this.options.peerBook;
     this.privateKey = this.options.privateKey;
-    this.bootnodes = this.options.bootnodes;
+    this.bootnodes = this.options.bootnodes || [];
 
+    this.chain = chain;
+    this.db = db;
 
     this.started = false;
     this.node = null;
@@ -89,18 +99,50 @@ export class P2PNetwork extends EventEmitter implements Service {
 
       });
 
+      // 2-way handshake
+      const protocol = "/eth/serenity/beacon/rpc/1";
+      // Placeholders to make this file compile temporarily
+      const helloMsg: Hello = {
+        networkId: 0,
+        chainId: 0,
+	latestFinalizedRoot: Buffer.from(""),
+        latestFinalizedEpoch: 0,
+        bestRoot: Buffer.from(""),
+        bestSlot: 0
+      };
+      this.node.handle(protocol, (proto, conn) => {
+        pull(
+          pull.values([Buffer.from(JSON.stringify(helloMsg))]),
+          conn,
+          pull.collect((values) => {
+	    // Peers' responses
+
+	  })
+        );	    
+      });
       this.node.on('peer:connect', (peerInfo) => {
         try {
           this.log.info(`Peer connected: ${peerInfo}`);
           this.peerBook.put(peerInfo);
-          this.discoveredPeers.add(peerInfo);
+	  this.discoveredPeers.add(peerInfo);
+	  this.node.dialProtocol(peerInfo, protocol, (err, conn) => {
+	    pull(
+              pull.values([Buffer.from(JSON.stringify(helloMsg))]),
+              conn,
+              pull.collect((values) => {
+	        // Peers responses
+
+	      })
+	    );
+	  });
+
         } catch (err) {
           this.log.error(err);
         }
       });
 
       this.node.on('peer:disconnect', (peerInfo) => {
-        try {
+        try { 
           this.peerBook.remove(peerInfo);
           this.discoveredPeers.delete(peerInfo);
         } catch (err) {

src/rpc/api/wire/index.ts

@@ -0,0 +1,7 @@
+import {WireProtocolApi} from "./wire";
+import {IWireProtocolApi} from "./interface";
+
+export {
+  WireProtocolApi,
+  IWireProtocolApi
+};

src/rpc/api/wire/interface.ts

@@ -0,0 +1,46 @@
+import {IApi} from "../interface";
+
+import {
+  Request,
+  Response,
+  Hello,
+  Goodbye,
+  GetStatus,
+  BeaconBlockRootsRequest,
+  BeaconBlockRootsResponse,
+  BeaconBlockHeaderRequest,
+  BeaconBlockHeaderResponse,
+  BeaconBlockBodiesRequest,
+  BeaconBlockBodiesResponse,
+  BeaconChainStateRequest,
+  BeaconChainStateResponse
+} from "./messages";
+
+export interface IWireProtocolApi extends IApi {
+
+  /**
+   * Returns metadata about the remote node.
+   */
+  GetStatus(): Promise<GetStatus>;
+
+  /**
+   * Returns list of block roots and slots from the peer
+   */
+  RequestBeaconBlockRoots(request: BeaconBlockRootsRequest): Promise<BeaconBlockRootsResponse>;
+
+  /**
+   * Returns beacon block headers from peer
+   */
+  RequestBeaconBlockHeaders(request: BeaconBlockHeadersRequest): Promise<BeaconBlockHeaderResponse>;
+
+  /**
+   * Returns block bodies associated with block roots from a peer
+   */
+  RequestBeaconBlockBodies(request: BeaconBlockBodiesRequest): Promise<BeaconBlockBodiesResponse>;
+
+  /**
+   * Returns the hashes of merkle tree nodes from merkelizing the block's state root.
+   */
+  RequestBeaconChainState(request: BeaconChainStateRequest): Promise<BeaconChainStateResponse>;
+
+}

src/rpc/api/wire/messages.ts

@@ -0,0 +1,91 @@
+import {Slot, bytes32, bytes, unint8, uint16, uint64} from "../../types/primitive";
+import {BlockRootSlot, HashTreeRoot} from "./types";
+
+interface RequestBody {
+
+}
+
+export interface Request {
+  id: uint64;
+  methodId: uint16;
+  body: RequestBody;
+}
+
+export interface Response {
+  id: uint64;
+  responseCode: uint16;
+  result: Buffer;
+}
+
+// Method ID: 0
+
+export interface Hello extends RequestBody {
+  networkId: uint64;
+  chainId: uint16;
+  latestFinalizedRoot: bytes32;
+  latestFinalizedEpoch: uint64;
+  bestRoot: bytes32;
+  bestSlot: Slot;
+}
+
+// Method ID: 1
+
+export interface Goodbye extends RequestBody {
+  reason: uint64;
+}
+
+// Method ID: 2
+
+export interface GetStatus extends RequestBody {
+  sha: bytes32;
+  userAgent: bytes;
+  timestamp: uint64;
+}
+
+// Method ID: 10
+
+export interface BeaconBlockRootsRequest extends RequestBody {
+  startSlot: Slot;
+  count: uint64;
+}
+
+export interface BeaconBlockRootsResponse {
+  blockRoot: bytes32;
+  slot: Slot;
+  // Doesn't currently exist as a standalone type
+  roots: []BlockRootSlot;
+}
+
+// Method ID: 11
+export interface BeaconBlockHeadersRequest extends RequestBody {
+  // Doesn't currently exist as a standalone type	
+  startRoot: HashTreeRoot; 
+  startSlot: Slot;
+  maxHeaders: uint64;
+  skipSlots: uint64;
+}
+
+export interface BeaconBlockHeadersResponse {
+  // Doesn't currently exist as a standalone type
+  headers: []BeaconBlockHeader;
+}
+
+// Method ID: 12
+export interface BeaconBlockBodiesRequest extends RequestBody {
+  blockRoots: []HashTreeRoot;
+} 
+
+export interface BeaconBlockBodiesResponse {
+  blockBodies: []BeaconBlockBody;
+}
+
+// Method ID: 13
+export interface BeaconChainStateRequest extends RequestBody {
+  hashes: []HashTreeRoot;
+}
+
+// Method ID: 14
+// Not yet defined in the ETH2.0 Wire spec.
+export interface BeaconChainStateResponse {
+
+}

src/rpc/api/wire/types.ts

@@ -0,0 +1,10 @@
+import {Slot} from "../../types/primitive"
+
+export interface BlockRootSlot {
+  block_root: Buffer;
+  slot: Slot;
+}
+
+export interface HashTreeRoot {
+  hash: Buffer;
+}

src/rpc/api/wire/wire.ts

@@ -0,0 +1,58 @@
+import {IWireProtocolApi} from "./interface";
+import {BeaconChain} from "../../../chain";
+import {DB} from "../../../db";
+
+import {
+  Request,
+  Response,
+  Hello,
+  Goodbye,
+  BeaconBlockRootsRequest,
+  BeaconBlockRootsResponse,
+  BeaconBlockHeaderRequest,
+  BeaconBlockHeaderResponse,
+  BeaconBlockBodiesRequest,
+  BeaconBlockBodiesResponse,
+  BeaconChainStateRequest,
+  BeaconChainStateResponse
+} from "./messages";
+
+import {
+  BlockRootSlot,
+  HashTreeRoot
+} from "./types";
+
+export class WireProtocolApi implements IWireProtocolApi {
+
+  public namespace: string;
+
+  private chain: BeaconChain;
+  private db: DB;
+
+  public constructor(opts, {chain, db}) {
+    this.namespace = 'wire';
+    this.db;
+    this.chain;
+  }
+
+  public async GetStatus(): Promise<GetStatus> {
+
+  }
+
+  public async RequestBeaconBlockRoots(request: BeaconBlockRootsRequest): Promise<BeaconBlockRootsResponse> {
+
+  }
+
+  public async RequestBeaconBlockHeaders(request: BeaconBlockHeadersRequest): Promise<BeaconBlockHeadersResponse> {
+
+  }
+
+  public async RequestBeaconBlockBodies(request: BeaconBlockBodiesRequest): Promise<BeaconBlockBodiesResponse> {
+
+  }
+
+  public async RequestBeaconChainState(request: BeaconChainStateRequest): Promise<BeaconChainStateResponse> {
+
+  }
+
+}