Sync Re-Write (#663)

* Apply clippy lints to beacon node

* Remove unnecessary logging and correct formatting

* Initial bones of load-balanced range-sync

* Port bump meshsup tests

* Further structure and network handling logic added

* Basic structure, ignoring error handling

* Correct max peers delay bug

* Clean up and re-write message processor and sync manager

* Restructure directory, correct type issues

* Fix compiler issues

* Completed first testing of new sync

* Correct merge issues

* Clean up warnings

* Push attestation processed log down to dbg

* Correct math error, downgraded logs

* Add RPC error handling and improved syncing code

* Add libp2p stream error handling and dropping of invalid peers

* Lower logs

* Add discovery tweak

* Correct libp2p service locking

* Handles peer disconnects for sync

* Add logs downgrade discovery log

* Less fork choice (#679)

* Try merge in change to reduce fork choice calls

* Remove fork choice from process block

* Minor log fix

* Check successes > 0

* Fix failing beacon chain tests

* Fix re-org warnings

* Fix mistake in prev commit

* Range sync refactor

- Introduces `ChainCollection`
- Correct Disconnect node handling
- Removes duplicate code

* Various bug fixes

* Remove unnecessary logs

* Maintain syncing state in the transition from finalied to head

* Improved disconnect handling

* Adds forwards block interator

* Notifies lighthouse on stream timeouts

* Apply new gossipsub updates

beacon_node/rest_api/src/validator.rs

@@ -251,7 +251,39 @@ pub fn publish_beacon_block<T: BeaconChainTypes>(
                             "block_slot" => slot,
                         );
 
-                        publish_beacon_block_to_network::<T>(network_chan, block)
+                        publish_beacon_block_to_network::<T>(network_chan, block)?;
+
+                        // Run the fork choice algorithm and enshrine a new canonical head, if
+                        // found.
+                        //
+                        // The new head may or may not be the block we just received.
+                        if let Err(e) = beacon_chain.fork_choice() {
+                            error!(
+                                log,
+                                "Failed to find beacon chain head";
+                                "error" => format!("{:?}", e)
+                            );
+                        } else {
+                            // In the best case, validators should produce blocks that become the
+                            // head.
+                            //
+                            // Potential reasons this may not be the case:
+                            //
+                            // - A quick re-org between block produce and publish.
+                            // - Excessive time between block produce and publish.
+                            // - A validator is using another beacon node to produce blocks and
+                            // submitting them here.
+                            if beacon_chain.head().beacon_block_root != block_root {
+                                warn!(
+                                    log,
+                                    "Block from validator is not head";
+                                    "desc" => "potential re-org",
+                                );
+
+                            }
+                        }
+
+                        Ok(())
                     }
                     Ok(outcome) => {
                         warn!(
@@ -278,8 +310,8 @@ pub fn publish_beacon_block<T: BeaconChainTypes>(
                         )))
                     }
                 }
-            })
-            .and_then(|_| response_builder?.body_no_ssz(&())),
+        })
+        .and_then(|_| response_builder?.body_no_ssz(&()))
     )
 }