Adds beacon chain events, websocket event handler

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1,6 +1,7 @@
 use crate::checkpoint::CheckPoint;
 use crate::errors::{BeaconChainError as Error, BlockProductionError};
 use crate::eth1_chain::{Eth1Chain, Eth1ChainBackend};
+use crate::events::{EventHandler, EventKind};
 use crate::fork_choice::{Error as ForkChoiceError, ForkChoice};
 use crate::iter::{ReverseBlockRootIterator, ReverseStateRootIterator};
 use crate::metrics;
@@ -95,6 +96,7 @@ pub trait BeaconChainTypes: Send + Sync + 'static {
     type LmdGhost: LmdGhost<Self::Store, Self::EthSpec>;
     type Eth1Chain: Eth1ChainBackend<Self::EthSpec>;
     type EthSpec: types::EthSpec;
+    type EventHandler: EventHandler<Self::EthSpec>;
 }
 
 /// Represents the "Beacon Chain" component of Ethereum 2.0. Allows import of blocks and block
@@ -117,6 +119,8 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     /// A state-machine that is updated with information from the network and chooses a canonical
     /// head block.
     pub fork_choice: ForkChoice<T>,
+    /// A handler for events generated by the beacon chain.
+    pub event_handler: T::EventHandler,
     /// Logging to CLI, etc.
     log: Logger,
 }
@@ -126,6 +130,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn from_genesis(
         store: Arc<T::Store>,
         eth1_backend: T::Eth1Chain,
+        event_handler: T::EventHandler,
         mut genesis_state: BeaconState<T::EthSpec>,
         mut genesis_block: BeaconBlock<T::EthSpec>,
         spec: ChainSpec,
@@ -174,6 +179,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             canonical_head,
             genesis_block_root,
             fork_choice: ForkChoice::new(store.clone(), &genesis_block, genesis_block_root),
+            event_handler,
             store,
             log,
         })
@@ -183,6 +189,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn from_store(
         store: Arc<T::Store>,
         eth1_backend: T::Eth1Chain,
+        event_handler: T::EventHandler,
         spec: ChainSpec,
         log: Logger,
     ) -> Result<Option<BeaconChain<T>>, Error> {
@@ -219,6 +226,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             slot_clock,
             fork_choice: ForkChoice::new(store.clone(), last_finalized_block, last_finalized_root),
             op_pool,
+            event_handler,
             eth1_chain: Eth1Chain::new(eth1_backend),
             canonical_head: RwLock::new(p.canonical_head),
             genesis_block_root: p.genesis_block_root,
@@ -629,6 +637,59 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn process_attestation(
         &self,
         attestation: Attestation<T::EthSpec>,
+    ) -> Result<AttestationProcessingOutcome, Error> {
+        let outcome = self.process_attestation_internal(attestation.clone());
+
+        match &outcome {
+            Ok(outcome) => match outcome {
+                AttestationProcessingOutcome::Processed => {
+                    trace!(
+                        self.log,
+                        "Beacon attestation imported";
+                        "shard" => attestation.data.crosslink.shard,
+                        "target_epoch" => attestation.data.target.epoch,
+                    );
+                    let _ = self
+                        .event_handler
+                        .register(EventKind::BeaconAttestationImported {
+                            attestation: Box::new(attestation),
+                        });
+                }
+                other => {
+                    warn!(
+                        self.log,
+                        "Beacon attestation rejected";
+                        "reason" => format!("{:?}", other),
+                    );
+                    let _ = self
+                        .event_handler
+                        .register(EventKind::BeaconAttestationRejected {
+                            reason: format!("Invalid attestation: {:?}", other),
+                            attestation: Box::new(attestation),
+                        });
+                }
+            },
+            Err(e) => {
+                error!(
+                    self.log,
+                    "Beacon attestation processing error";
+                    "error" => format!("{:?}", e),
+                );
+                let _ = self
+                    .event_handler
+                    .register(EventKind::BeaconAttestationRejected {
+                        reason: format!("Internal error: {:?}", e),
+                        attestation: Box::new(attestation),
+                    });
+            }
+        }
+
+        outcome
+    }
+
+    pub fn process_attestation_internal(
+        &self,
+        attestation: Attestation<T::EthSpec>,
     ) -> Result<AttestationProcessingOutcome, Error> {
         metrics::inc_counter(&metrics::ATTESTATION_PROCESSING_REQUESTS);
         let timer = metrics::start_timer(&metrics::ATTESTATION_PROCESSING_TIMES);
@@ -932,6 +993,57 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn process_block(
         &self,
         block: BeaconBlock<T::EthSpec>,
+    ) -> Result<BlockProcessingOutcome, Error> {
+        let outcome = self.process_block_internal(block.clone());
+
+        match &outcome {
+            Ok(outcome) => match outcome {
+                BlockProcessingOutcome::Processed { block_root } => {
+                    trace!(
+                        self.log,
+                        "Beacon block imported";
+                        "block_root" => format!("{:?}", block_root),
+                        "block_slot" => format!("{:?}", block_root),
+                    );
+                    let _ = self.event_handler.register(EventKind::BeaconBlockImported {
+                        block_root: *block_root,
+                        block: Box::new(block),
+                    });
+                }
+                other => {
+                    warn!(
+                        self.log,
+                        "Beacon block rejected";
+                        "reason" => format!("{:?}", other),
+                    );
+                    let _ = self.event_handler.register(EventKind::BeaconBlockRejected {
+                        reason: format!("Invalid block: {:?}", other),
+                        block: Box::new(block),
+                    });
+                }
+            },
+            Err(e) => {
+                error!(
+                    self.log,
+                    "Beacon block processing error";
+                    "error" => format!("{:?}", e),
+                );
+                let _ = self.event_handler.register(EventKind::BeaconBlockRejected {
+                    reason: format!("Internal error: {:?}", e),
+                    block: Box::new(block),
+                });
+            }
+        }
+
+        outcome
+    }
+
+    /// Accept some block and attempt to add it to block DAG.
+    ///
+    /// Will accept blocks from prior slots, however it will reject any block from a future slot.
+    fn process_block_internal(
+        &self,
+        block: BeaconBlock<T::EthSpec>,
     ) -> Result<BlockProcessingOutcome, Error> {
         metrics::inc_counter(&metrics::BLOCK_PROCESSING_REQUESTS);
         let full_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_TIMES);

beacon_node/beacon_chain/src/beacon_chain_builder.rs

@@ -131,10 +131,11 @@ impl<T: BeaconChainTypes> BeaconChainBuilder<T> {
         self,
         store: Arc<T::Store>,
         eth1_backend: T::Eth1Chain,
+        event_handler: T::EventHandler,
     ) -> Result<BeaconChain<T>, String> {
         Ok(match self.build_strategy {
             BuildStrategy::LoadFromStore => {
-                BeaconChain::from_store(store, eth1_backend, self.spec, self.log)
+                BeaconChain::from_store(store, eth1_backend, event_handler, self.spec, self.log)
                     .map_err(|e| format!("Error loading BeaconChain from database: {:?}", e))?
                     .ok_or_else(|| format!("Unable to find exising BeaconChain in database."))?
             }
@@ -144,6 +145,7 @@ impl<T: BeaconChainTypes> BeaconChainBuilder<T> {
             } => BeaconChain::from_genesis(
                 store,
                 eth1_backend,
+                event_handler,
                 genesis_state.as_ref().clone(),
                 genesis_block.as_ref().clone(),
                 self.spec,

beacon_node/beacon_chain/src/events.rs

@@ -0,0 +1,51 @@
+use serde_derive::{Deserialize, Serialize};
+use std::marker::PhantomData;
+use types::{Attestation, BeaconBlock, EthSpec, Hash256};
+
+pub trait EventHandler<T: EthSpec>: Sized + Send + Sync {
+    fn register(&self, kind: EventKind<T>) -> Result<(), String>;
+}
+
+pub struct NullEventHandler<T: EthSpec>(PhantomData<T>);
+
+impl<T: EthSpec> EventHandler<T> for NullEventHandler<T> {
+    fn register(&self, _kind: EventKind<T>) -> Result<(), String> {
+        Ok(())
+    }
+}
+
+impl<T: EthSpec> Default for NullEventHandler<T> {
+    fn default() -> Self {
+        NullEventHandler(PhantomData)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(
+    bound = "T: EthSpec",
+    rename_all = "snake_case",
+    tag = "event",
+    content = "data"
+)]
+pub enum EventKind<T: EthSpec> {
+    BeaconHeadChanged {
+        reorg: bool,
+        current_head_beacon_block_root: Hash256,
+        previous_head_beacon_block_root: Hash256,
+    },
+    BeaconBlockImported {
+        block_root: Hash256,
+        block: Box<BeaconBlock<T>>,
+    },
+    BeaconBlockRejected {
+        reason: String,
+        block: Box<BeaconBlock<T>>,
+    },
+    BeaconAttestationImported {
+        attestation: Box<Attestation<T>>,
+    },
+    BeaconAttestationRejected {
+        reason: String,
+        attestation: Box<Attestation<T>>,
+    },
+}

beacon_node/beacon_chain/src/lib.rs

@@ -7,6 +7,7 @@ mod beacon_chain_builder;
 mod checkpoint;
 mod errors;
 mod eth1_chain;
+pub mod events;
 mod fork_choice;
 mod iter;
 mod metrics;

beacon_node/beacon_chain/src/test_utils.rs

@@ -1,6 +1,6 @@
 use crate::{
-    AttestationProcessingOutcome, BeaconChain, BeaconChainBuilder, BeaconChainTypes,
-    BlockProcessingOutcome, InteropEth1ChainBackend,
+    events::NullEventHandler, AttestationProcessingOutcome, BeaconChain, BeaconChainBuilder,
+    BeaconChainTypes, BlockProcessingOutcome, InteropEth1ChainBackend,
 };
 use lmd_ghost::LmdGhost;
 use rayon::prelude::*;
@@ -68,6 +68,7 @@ where
     type LmdGhost = L;
     type Eth1Chain = InteropEth1ChainBackend<E>;
     type EthSpec = E;
+    type EventHandler = NullEventHandler<E>;
 }
 
 /// A testing harness which can instantiate a `BeaconChain` and populate it with blocks and
@@ -103,7 +104,11 @@ where
         let chain =
             BeaconChainBuilder::quick_start(HARNESS_GENESIS_TIME, &keypairs, spec.clone(), log)
                 .unwrap_or_else(|e| panic!("Failed to create beacon chain builder: {}", e))
-                .build(store.clone(), InteropEth1ChainBackend::default())
+                .build(
+                    store.clone(),
+                    InteropEth1ChainBackend::default(),
+                    NullEventHandler::default(),
+                )
                 .unwrap_or_else(|e| panic!("Failed to build beacon chain: {}", e));
 
         Self {