Merge remote-tracking branch 'origin/unstable' into tree-states

consensus/types/src/payload.rs

@@ -39,6 +39,7 @@ pub trait ExecPayload<T: EthSpec>: Debug + Clone + PartialEq + Hash + TreeHash +
     fn transactions(&self) -> Option<&Transactions<T>>;
     /// fork-specific fields
     fn withdrawals_root(&self) -> Result<Hash256, Error>;
+    fn blob_gas_used(&self) -> Result<u64, Error>;
 
     /// Is this a default payload with 0x0 roots for transactions and withdrawals?
     fn is_default_with_zero_roots(&self) -> bool;
@@ -254,6 +255,13 @@ impl<T: EthSpec> ExecPayload<T> for FullPayload<T> {
         }
     }
 
+    fn blob_gas_used(&self) -> Result<u64, Error> {
+        match self {
+            FullPayload::Merge(_) | FullPayload::Capella(_) => Err(Error::IncorrectStateVariant),
+            FullPayload::Deneb(ref inner) => Ok(inner.execution_payload.blob_gas_used),
+        }
+    }
+
     fn is_default_with_zero_roots<'a>(&'a self) -> bool {
         map_full_payload_ref!(&'a _, self.to_ref(), move |payload, cons| {
             cons(payload);
@@ -372,6 +380,15 @@ impl<'b, T: EthSpec> ExecPayload<T> for FullPayloadRef<'b, T> {
         }
     }
 
+    fn blob_gas_used(&self) -> Result<u64, Error> {
+        match self {
+            FullPayloadRef::Merge(_) | FullPayloadRef::Capella(_) => {
+                Err(Error::IncorrectStateVariant)
+            }
+            FullPayloadRef::Deneb(inner) => Ok(inner.execution_payload.blob_gas_used),
+        }
+    }
+
     fn is_default_with_zero_roots<'a>(&'a self) -> bool {
         map_full_payload_ref!(&'a _, self, move |payload, cons| {
             cons(payload);
@@ -533,6 +550,15 @@ impl<T: EthSpec> ExecPayload<T> for BlindedPayload<T> {
         }
     }
 
+    fn blob_gas_used(&self) -> Result<u64, Error> {
+        match self {
+            BlindedPayload::Merge(_) | BlindedPayload::Capella(_) => {
+                Err(Error::IncorrectStateVariant)
+            }
+            BlindedPayload::Deneb(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
+        }
+    }
+
     fn is_default_with_zero_roots(&self) -> bool {
         self.to_ref().is_default_with_zero_roots()
     }
@@ -621,6 +647,15 @@ impl<'b, T: EthSpec> ExecPayload<T> for BlindedPayloadRef<'b, T> {
         }
     }
 
+    fn blob_gas_used(&self) -> Result<u64, Error> {
+        match self {
+            BlindedPayloadRef::Merge(_) | BlindedPayloadRef::Capella(_) => {
+                Err(Error::IncorrectStateVariant)
+            }
+            BlindedPayloadRef::Deneb(inner) => Ok(inner.execution_payload_header.blob_gas_used),
+        }
+    }
+
     fn is_default_with_zero_roots<'a>(&'a self) -> bool {
         map_blinded_payload_ref!(&'b _, self, move |payload, cons| {
             cons(payload);
@@ -646,7 +681,8 @@ macro_rules! impl_exec_payload_common {
      $block_type_variant:ident,     // Blinded                      |   Full
      $is_default_with_empty_roots:block,
      $f:block,
-     $g:block) => {
+     $g:block,
+     $h:block) => {
         impl<T: EthSpec> ExecPayload<T> for $wrapper_type<T> {
             fn block_type() -> BlockType {
                 BlockType::$block_type_variant
@@ -704,6 +740,11 @@ macro_rules! impl_exec_payload_common {
                 let g = $g;
                 g(self)
             }
+
+            fn blob_gas_used(&self) -> Result<u64, Error> {
+                let h = $h;
+                h(self)
+            }
         }
 
         impl<T: EthSpec> From<$wrapped_type<T>> for $wrapper_type<T> {
@@ -741,6 +782,14 @@ macro_rules! impl_exec_payload_for_fork {
                         wrapper_ref_type.withdrawals_root()
                     };
                 c
+            },
+            {
+                let c: for<'a> fn(&'a $wrapper_type_header<T>) -> Result<u64, Error> =
+                    |payload: &$wrapper_type_header<T>| {
+                        let wrapper_ref_type = BlindedPayloadRef::$fork_variant(&payload);
+                        wrapper_ref_type.blob_gas_used()
+                    };
+                c
             }
         );
 
@@ -820,6 +869,14 @@ macro_rules! impl_exec_payload_for_fork {
                         wrapper_ref_type.withdrawals_root()
                     };
                 c
+            },
+            {
+                let c: for<'a> fn(&'a $wrapper_type_full<T>) -> Result<u64, Error> =
+                    |payload: &$wrapper_type_full<T>| {
+                        let wrapper_ref_type = FullPayloadRef::$fork_variant(&payload);
+                        wrapper_ref_type.blob_gas_used()
+                    };
+                c
             }
         );
 

consensus/types/src/signed_beacon_block.rs

@@ -104,6 +104,16 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> SignedBeaconBlock<E, Payload>
         Self::from_ssz_bytes_with(bytes, |bytes| BeaconBlock::from_ssz_bytes(bytes, spec))
     }
 
+    /// SSZ decode with explicit fork variant.
+    pub fn from_ssz_bytes_for_fork(
+        bytes: &[u8],
+        fork_name: ForkName,
+    ) -> Result<Self, ssz::DecodeError> {
+        Self::from_ssz_bytes_with(bytes, |bytes| {
+            BeaconBlock::from_ssz_bytes_for_fork(bytes, fork_name)
+        })
+    }
+
     /// SSZ decode which attempts to decode all variants (slow).
     pub fn any_from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
         Self::from_ssz_bytes_with(bytes, BeaconBlock::any_from_ssz_bytes)