Builder flow for Deneb & Blobs (#4428)

* Add Deneb builder flow types with generics

* Update validator client `get_blinded_blocks` call to support Deneb

* `produceBlindedBlock` endpoint updates:
- Handle new Deneb BuilderBid response from builder endpoint (new BlindedBlobsBundle type)
- Build BlockContents response (containing kzg_commitments, proof and blinded_blob_sidecars)

* Appease Clippy lint

* Partial implementation of submit blinded block & blobs. Refactor existing `BlobSidecar` related types to support blinded blobs.

* Add associated types for BlockProposal

* Rename `AbstractSidecar` to `Sidecar`

* Remove blob cache as it's no longer necessary

* Remove unnecessary enum variant

* Clean up

* Hanlde unblinded blobs and publish full block contents

* Fix tests

* Add local EL blobs caching in blinded flow

* Remove BlockProposal and move associated Sidecar trait to AbstractExecPayload to simplify changes

* add blob roots associated type

* move raw blobs associated type to sidecar trait

* Fix todos and improve error handling

* Consolidate BlobsBundle from `execution_layer` into `consensus/types`

* Rename RawBlobs, Blobs, and BlobRoots

* Use `BlobRoots` type alias

* Update error message.

Co-authored-by: realbigsean <seananderson33@GMAIL.com>

* update builder bid type

# Conflicts:
#	consensus/types/src/builder_bid.rs

* Fix lint

* remove generic from builder bid

---------

Co-authored-by: realbigsean <seananderson33@gmail.com>

validator_client/src/block_service.rs

@@ -525,7 +525,7 @@ impl<T: SlotClock + 'static, E: EthSpec> BlockService<T, E> {
             Some(blob_sidecars) => {
                 match self_ref
                     .validator_store
-                    .sign_blobs(*validator_pubkey_ref, blob_sidecars)
+                    .sign_blobs::<Payload>(*validator_pubkey_ref, blob_sidecars)
                     .await
                 {
                     Ok(signed_blobs) => Some(signed_blobs),
@@ -620,16 +620,15 @@ impl<T: SlotClock + 'static, E: EthSpec> BlockService<T, E> {
                     &metrics::BLOCK_SERVICE_TIMES,
                     &[metrics::BLINDED_BEACON_BLOCK_HTTP_POST],
                 );
-                todo!("need to be adjusted for blobs");
-                // beacon_node
-                //     .post_beacon_blinded_blocks(signed_block_contents.signed_block())
-                //     .await
-                //     .map_err(|e| {
-                //         BlockError::Irrecoverable(format!(
-                //             "Error from beacon node when publishing block: {:?}",
-                //             e
-                //         ))
-                //     })?
+                beacon_node
+                    .post_beacon_blinded_blocks(signed_block_contents)
+                    .await
+                    .map_err(|e| {
+                        BlockError::Irrecoverable(format!(
+                            "Error from beacon node when publishing block: {:?}",
+                            e
+                        ))
+                    })?
             }
         }
         Ok::<_, BlockError>(())
@@ -665,21 +664,20 @@ impl<T: SlotClock + 'static, E: EthSpec> BlockService<T, E> {
                     &metrics::BLOCK_SERVICE_TIMES,
                     &[metrics::BLINDED_BEACON_BLOCK_HTTP_GET],
                 );
-                todo!("implement blinded flow for blobs");
-                // beacon_node
-                //     .get_validator_blinded_blocks::<E, Payload>(
-                //         slot,
-                //         randao_reveal_ref,
-                //         graffiti.as_ref(),
-                //     )
-                //     .await
-                //     .map_err(|e| {
-                //         BlockError::Recoverable(format!(
-                //             "Error from beacon node when producing block: {:?}",
-                //             e
-                //         ))
-                //     })?
-                //     .data
+                beacon_node
+                    .get_validator_blinded_blocks::<E, Payload>(
+                        slot,
+                        randao_reveal_ref,
+                        graffiti.as_ref(),
+                    )
+                    .await
+                    .map_err(|e| {
+                        BlockError::Recoverable(format!(
+                            "Error from beacon node when producing block: {:?}",
+                            e
+                        ))
+                    })?
+                    .data
             }
         };
 

validator_client/src/signing_method.rs

@@ -37,7 +37,7 @@ pub enum Error {
 pub enum SignableMessage<'a, T: EthSpec, Payload: AbstractExecPayload<T> = FullPayload<T>> {
     RandaoReveal(Epoch),
     BeaconBlock(&'a BeaconBlock<T, Payload>),
-    BlobSidecar(&'a BlobSidecar<T>),
+    BlobSidecar(&'a Payload::Sidecar),
     AttestationData(&'a AttestationData),
     SignedAggregateAndProof(&'a AggregateAndProof<T>),
     SelectionProof(Slot),

validator_client/src/validator_store.rs

@@ -20,10 +20,10 @@ use std::sync::Arc;
 use task_executor::TaskExecutor;
 use types::{
     attestation::Error as AttestationError, graffiti::GraffitiString, AbstractExecPayload, Address,
-    AggregateAndProof, Attestation, BeaconBlock, BlindedPayload, BlobSidecarList, ChainSpec,
-    ContributionAndProof, Domain, Epoch, EthSpec, Fork, ForkName, Graffiti, Hash256, Keypair,
-    PublicKeyBytes, SelectionProof, Signature, SignedAggregateAndProof, SignedBeaconBlock,
-    SignedBlobSidecar, SignedBlobSidecarList, SignedContributionAndProof, SignedRoot,
+    AggregateAndProof, Attestation, BeaconBlock, BlindedPayload, ChainSpec, ContributionAndProof,
+    Domain, Epoch, EthSpec, Fork, ForkName, Graffiti, Hash256, Keypair, PublicKeyBytes,
+    SelectionProof, Sidecar, SidecarList, Signature, SignedAggregateAndProof, SignedBeaconBlock,
+    SignedContributionAndProof, SignedRoot, SignedSidecar, SignedSidecarList,
     SignedValidatorRegistrationData, SignedVoluntaryExit, Slot, SyncAggregatorSelectionData,
     SyncCommitteeContribution, SyncCommitteeMessage, SyncSelectionProof, SyncSubnetId,
     ValidatorRegistrationData, VoluntaryExit,
@@ -566,22 +566,21 @@ impl<T: SlotClock + 'static, E: EthSpec> ValidatorStore<T, E> {
         }
     }
 
-    pub async fn sign_blobs(
+    pub async fn sign_blobs<Payload: AbstractExecPayload<E>>(
         &self,
         validator_pubkey: PublicKeyBytes,
-        blob_sidecars: BlobSidecarList<E>,
-    ) -> Result<SignedBlobSidecarList<E>, Error> {
+        blob_sidecars: SidecarList<E, Payload::Sidecar>,
+    ) -> Result<SignedSidecarList<E, Payload::Sidecar>, Error> {
         let mut signed_blob_sidecars = Vec::new();
-
         for blob_sidecar in blob_sidecars.into_iter() {
-            let slot = blob_sidecar.slot;
+            let slot = blob_sidecar.slot();
             let signing_epoch = slot.epoch(E::slots_per_epoch());
             let signing_context = self.signing_context(Domain::BlobSidecar, signing_epoch);
             let signing_method = self.doppelganger_checked_signing_method(validator_pubkey)?;
 
             let signature = signing_method
-                .get_signature::<E, BlindedPayload<E>>(
-                    SignableMessage::BlobSidecar(&blob_sidecar),
+                .get_signature::<E, Payload>(
+                    SignableMessage::BlobSidecar(blob_sidecar.as_ref()),
                     signing_context,
                     &self.spec,
                     &self.task_executor,
@@ -590,9 +589,10 @@ impl<T: SlotClock + 'static, E: EthSpec> ValidatorStore<T, E> {
 
             metrics::inc_counter_vec(&metrics::SIGNED_BLOBS_TOTAL, &[metrics::SUCCESS]);
 
-            signed_blob_sidecars.push(SignedBlobSidecar {
+            signed_blob_sidecars.push(SignedSidecar {
                 message: blob_sidecar,
                 signature,
+                _phantom: PhantomData,
             });
         }