Optionally skip RANDAO verification during block production (#3116)

## Proposed Changes

Allow Lighthouse to speculatively create blocks via the `/eth/v1/validators/blocks` endpoint by optionally skipping the RANDAO verification that we introduced in #2740. When `verify_randao=false` is passed as a query parameter the `randao_reveal` is not required to be present, and if present will only be lightly checked (must be a valid BLS sig). If `verify_randao` is omitted it defaults to true and Lighthouse behaves exactly as it did previously, hence this PR is backwards-compatible.

I'd like to get this change into `unstable` pretty soon as I've got 3 projects building on top of it:

- [`blockdreamer`](https://github.com/michaelsproul/blockdreamer), which mocks block production every slot in order to fingerprint clients
- analysis of Lighthouse's block packing _optimality_, which uses `blockdreamer` to extract interesting instances of the attestation packing problem
- analysis of Lighthouse's block packing _performance_ (as in speed) on the `tree-states` branch

## Additional Info

Having tested `blockdreamer` with Prysm, Nimbus and Teku I noticed that none of them verify the randao signature on `/eth/v1/validator/blocks`. I plan to open a PR to the `beacon-APIs` repo anyway so that this parameter can be standardised in case the other clients add RANDAO verification by default in future.

beacon_node/http_api/src/lib.rs

@@ -23,7 +23,7 @@ use beacon_chain::{
     observed_operations::ObservationOutcome,
     validator_monitor::{get_block_delay_ms, timestamp_now},
     AttestationError as AttnError, BeaconChain, BeaconChainError, BeaconChainTypes,
-    HeadSafetyStatus, WhenSlotSkipped,
+    HeadSafetyStatus, ProduceBlockVerification, WhenSlotSkipped,
 };
 use block_id::BlockId;
 use eth2::types::{self as api_types, EndpointVersion, ValidatorId};
@@ -46,7 +46,7 @@ use tokio::sync::mpsc::UnboundedSender;
 use tokio_stream::{wrappers::BroadcastStream, StreamExt};
 use types::{
     Attestation, AttesterSlashing, BeaconStateError, CommitteeCache, ConfigAndPreset, Epoch,
-    EthSpec, ForkName, ProposerPreparationData, ProposerSlashing, RelativeEpoch,
+    EthSpec, ForkName, ProposerPreparationData, ProposerSlashing, RelativeEpoch, Signature,
     SignedAggregateAndProof, SignedBeaconBlock, SignedContributionAndProof, SignedVoluntaryExit,
     Slot, SyncCommitteeMessage, SyncContributionData,
 };
@@ -1872,15 +1872,39 @@ pub fn serve<T: BeaconChainTypes>(
              query: api_types::ValidatorBlocksQuery,
              chain: Arc<BeaconChain<T>>| {
                 blocking_json_task(move || {
-                    let randao_reveal = (&query.randao_reveal).try_into().map_err(|e| {
-                        warp_utils::reject::custom_bad_request(format!(
-                            "randao reveal is not valid BLS signature: {:?}",
-                            e
-                        ))
-                    })?;
+                    let randao_reveal = query.randao_reveal.as_ref().map_or_else(
+                        || {
+                            if query.verify_randao {
+                                Err(warp_utils::reject::custom_bad_request(
+                                    "randao_reveal is mandatory unless verify_randao=false".into(),
+                                ))
+                            } else {
+                                Ok(Signature::empty())
+                            }
+                        },
+                        |sig_bytes| {
+                            sig_bytes.try_into().map_err(|e| {
+                                warp_utils::reject::custom_bad_request(format!(
+                                    "randao reveal is not a valid BLS signature: {:?}",
+                                    e
+                                ))
+                            })
+                        },
+                    )?;
+
+                    let randao_verification = if query.verify_randao {
+                        ProduceBlockVerification::VerifyRandao
+                    } else {
+                        ProduceBlockVerification::NoVerification
+                    };
 
                     let (block, _) = chain
-                        .produce_block(randao_reveal, slot, query.graffiti.map(Into::into))
+                        .produce_block_with_verification(
+                            randao_reveal,
+                            slot,
+                            query.graffiti.map(Into::into),
+                            randao_verification,
+                        )
                         .map_err(warp_utils::reject::block_production_error)?;
                     let fork_name = block
                         .to_ref()