Create BeaconChainTypes, thread through runtime

beacon_node/rpc/src/attestation.rs

@@ -1,4 +1,4 @@
-use crate::beacon_chain::BeaconChain;
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use futures::Future;
 use grpcio::{RpcContext, RpcStatus, RpcStatusCode, UnarySink};
 use protos::services::{
@@ -9,15 +9,15 @@ use protos::services_grpc::AttestationService;
 use slog::{error, info, trace, warn};
 use ssz::{ssz_encode, Decode};
 use std::sync::Arc;
-use types::{Attestation, EthSpec};
+use types::Attestation;
 
 #[derive(Clone)]
-pub struct AttestationServiceInstance<E: EthSpec> {
-    pub chain: Arc<BeaconChain<E>>,
+pub struct AttestationServiceInstance<T: BeaconChainTypes> {
+    pub chain: Arc<BeaconChain<T>>,
     pub log: slog::Logger,
 }
 
-impl<E: EthSpec> AttestationService for AttestationServiceInstance<E> {
+impl<T: BeaconChainTypes> AttestationService for AttestationServiceInstance<T> {
     /// Produce the `AttestationData` for signing by a validator.
     fn produce_attestation_data(
         &mut self,

beacon_node/rpc/src/beacon_block.rs

@@ -1,4 +1,4 @@
-use crate::beacon_chain::BeaconChain;
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use crossbeam_channel;
 use eth2_libp2p::PubsubMessage;
 use futures::Future;
@@ -13,16 +13,16 @@ use slog::Logger;
 use slog::{error, info, trace, warn};
 use ssz::{ssz_encode, Decode};
 use std::sync::Arc;
-use types::{BeaconBlock, EthSpec, Signature, Slot};
+use types::{BeaconBlock, Signature, Slot};
 
 #[derive(Clone)]
-pub struct BeaconBlockServiceInstance<E: EthSpec> {
-    pub chain: Arc<BeaconChain<E>>,
+pub struct BeaconBlockServiceInstance<T: BeaconChainTypes> {
+    pub chain: Arc<BeaconChain<T>>,
     pub network_chan: crossbeam_channel::Sender<NetworkMessage>,
     pub log: Logger,
 }
 
-impl<E: EthSpec> BeaconBlockService for BeaconBlockServiceInstance<E> {
+impl<T: BeaconChainTypes> BeaconBlockService for BeaconBlockServiceInstance<T> {
     /// Produce a `BeaconBlock` for signing by a validator.
     fn produce_beacon_block(
         &mut self,

beacon_node/rpc/src/beacon_chain.rs

@@ -1,22 +1,19 @@
 use beacon_chain::BeaconChain as RawBeaconChain;
 use beacon_chain::{
-    fork_choice::ForkChoice,
     parking_lot::{RwLockReadGuard, RwLockWriteGuard},
-    slot_clock::SlotClock,
-    store::Store,
     types::{BeaconState, ChainSpec, Signature},
     AttestationValidationError, BlockProductionError,
 };
-pub use beacon_chain::{BeaconChainError, BlockProcessingOutcome};
+pub use beacon_chain::{BeaconChainError, BeaconChainTypes, BlockProcessingOutcome};
 use types::{Attestation, AttestationData, BeaconBlock, EthSpec};
 
 /// The RPC's API to the beacon chain.
-pub trait BeaconChain<E: EthSpec>: Send + Sync {
+pub trait BeaconChain<T: BeaconChainTypes>: Send + Sync {
     fn get_spec(&self) -> &ChainSpec;
 
-    fn get_state(&self) -> RwLockReadGuard<BeaconState<E>>;
+    fn get_state(&self) -> RwLockReadGuard<BeaconState<T::EthSpec>>;
 
-    fn get_mut_state(&self) -> RwLockWriteGuard<BeaconState<E>>;
+    fn get_mut_state(&self) -> RwLockWriteGuard<BeaconState<T::EthSpec>>;
 
     fn process_block(&self, block: BeaconBlock)
         -> Result<BlockProcessingOutcome, BeaconChainError>;
@@ -24,7 +21,7 @@ pub trait BeaconChain<E: EthSpec>: Send + Sync {
     fn produce_block(
         &self,
         randao_reveal: Signature,
-    ) -> Result<(BeaconBlock, BeaconState<E>), BlockProductionError>;
+    ) -> Result<(BeaconBlock, BeaconState<T::EthSpec>), BlockProductionError>;
 
     fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, BeaconChainError>;
 
@@ -34,22 +31,16 @@ pub trait BeaconChain<E: EthSpec>: Send + Sync {
     ) -> Result<(), AttestationValidationError>;
 }
 
-impl<T, U, F, E> BeaconChain<E> for RawBeaconChain<T, U, F, E>
-where
-    T: Store,
-    U: SlotClock,
-    F: ForkChoice,
-    E: EthSpec,
-{
+impl<T: BeaconChainTypes> BeaconChain<T> for RawBeaconChain<T> {
     fn get_spec(&self) -> &ChainSpec {
         &self.spec
     }
 
-    fn get_state(&self) -> RwLockReadGuard<BeaconState<E>> {
+    fn get_state(&self) -> RwLockReadGuard<BeaconState<T::EthSpec>> {
         self.state.read()
     }
 
-    fn get_mut_state(&self) -> RwLockWriteGuard<BeaconState<E>> {
+    fn get_mut_state(&self) -> RwLockWriteGuard<BeaconState<T::EthSpec>> {
         self.state.write()
     }
 
@@ -63,7 +54,7 @@ where
     fn produce_block(
         &self,
         randao_reveal: Signature,
-    ) -> Result<(BeaconBlock, BeaconState<E>), BlockProductionError> {
+    ) -> Result<(BeaconBlock, BeaconState<T::EthSpec>), BlockProductionError> {
         self.produce_block(randao_reveal)
     }
 

beacon_node/rpc/src/beacon_node.rs

@@ -1,19 +1,18 @@
-use crate::beacon_chain::BeaconChain;
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use futures::Future;
 use grpcio::{RpcContext, UnarySink};
 use protos::services::{Empty, Fork, NodeInfoResponse};
 use protos::services_grpc::BeaconNodeService;
 use slog::{trace, warn};
 use std::sync::Arc;
-use types::EthSpec;
 
 #[derive(Clone)]
-pub struct BeaconNodeServiceInstance<E: EthSpec> {
-    pub chain: Arc<BeaconChain<E>>,
+pub struct BeaconNodeServiceInstance<T: BeaconChainTypes> {
+    pub chain: Arc<BeaconChain<T>>,
     pub log: slog::Logger,
 }
 
-impl<E: EthSpec> BeaconNodeService for BeaconNodeServiceInstance<E> {
+impl<T: BeaconChainTypes> BeaconNodeService for BeaconNodeServiceInstance<T> {
     /// Provides basic node information.
     fn info(&mut self, ctx: RpcContext, _req: Empty, sink: UnarySink<NodeInfoResponse>) {
         trace!(self.log, "Node info requested via RPC");

beacon_node/rpc/src/lib.rs

@@ -7,7 +7,7 @@ mod validator;
 
 use self::attestation::AttestationServiceInstance;
 use self::beacon_block::BeaconBlockServiceInstance;
-use self::beacon_chain::BeaconChain;
+use self::beacon_chain::{BeaconChain, BeaconChainTypes};
 use self::beacon_node::BeaconNodeServiceInstance;
 use self::validator::ValidatorServiceInstance;
 pub use config::Config as RPCConfig;
@@ -21,13 +21,12 @@ use protos::services_grpc::{
 use slog::{info, o, warn};
 use std::sync::Arc;
 use tokio::runtime::TaskExecutor;
-use types::EthSpec;
 
-pub fn start_server<E: EthSpec>(
+pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
     config: &RPCConfig,
     executor: &TaskExecutor,
     network_chan: crossbeam_channel::Sender<NetworkMessage>,
-    beacon_chain: Arc<BeaconChain<E>>,
+    beacon_chain: Arc<BeaconChain<T>>,
     log: &slog::Logger,
 ) -> exit_future::Signal {
     let log = log.new(o!("Service"=>"RPC"));

beacon_node/rpc/src/validator.rs

@@ -1,4 +1,4 @@
-use crate::beacon_chain::BeaconChain;
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use bls::PublicKey;
 use futures::Future;
 use grpcio::{RpcContext, RpcStatus, RpcStatusCode, UnarySink};
@@ -7,16 +7,16 @@ use protos::services_grpc::ValidatorService;
 use slog::{trace, warn};
 use ssz::Decode;
 use std::sync::Arc;
-use types::{Epoch, EthSpec, RelativeEpoch};
+use types::{Epoch, RelativeEpoch};
 
 #[derive(Clone)]
-pub struct ValidatorServiceInstance<E: EthSpec> {
-    pub chain: Arc<BeaconChain<E>>,
+pub struct ValidatorServiceInstance<T: BeaconChainTypes> {
+    pub chain: Arc<BeaconChain<T>>,
     pub log: slog::Logger,
 }
 //TODO: Refactor Errors
 
-impl<E: EthSpec> ValidatorService for ValidatorServiceInstance<E> {
+impl<T: BeaconChainTypes> ValidatorService for ValidatorServiceInstance<T> {
     /// For a list of validator public keys, this function returns the slot at which each
     /// validator must propose a block, attest to a shard, their shard committee and the shard they
     /// need to attest to.