Skip to content

custom deserde impl #2017

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 9 commits into from
Feb 9, 2025
Merged

custom deserde impl #2017

Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
4397730
custom deserde impl
siosw Feb 6, 2025
1eb2250
more thorough tests
siosw Feb 6, 2025
e50a5e9
fix no std
siosw Feb 6, 2025
cbca2e8
deserde enum
siosw Feb 7, 2025
9f5cb34
rm dead code
siosw Feb 7, 2025
eab7346
minimize serde imports
siosw Feb 7, 2025
26f8ca5
move last import
siosw Feb 7, 2025
3ff1d8e
roundtrip test
siosw Feb 8, 2025
e686a2a
reduce nesting
siosw Feb 8, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
258 changes: 246 additions & 12 deletions crates/rpc-types-engine/src/payload.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1051,25 +1051,210 @@ impl<T: Decodable2718> TryFrom<ExecutionPayload> for Block<T> {
}
}

// Deserializes untagged ExecutionPayload by trying each variant in falling order
// Deserializes untagged ExecutionPayload depending on the available fields
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for ExecutionPayload {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(serde::Deserialize)]
#[serde(untagged)]
enum ExecutionPayloadDesc {
V3(ExecutionPayloadV3),
V2(ExecutionPayloadV2),
V1(ExecutionPayloadV1),
}
match ExecutionPayloadDesc::deserialize(deserializer)? {
ExecutionPayloadDesc::V3(payload) => Ok(Self::V3(payload)),
ExecutionPayloadDesc::V2(payload) => Ok(Self::V2(payload)),
ExecutionPayloadDesc::V1(payload) => Ok(Self::V1(payload)),
struct ExecutionPayloadVisitor;

impl<'de> serde::de::Visitor<'de> for ExecutionPayloadVisitor {
type Value = ExecutionPayload;

fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("a valid ExecutionPayload object")
}

fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use serde::de::IntoDeserializer;

// this currently rejects unknown fields
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(field_identifier, rename_all = "camelCase"))]
enum Fields {
ParentHash,
FeeRecipient,
StateRoot,
ReceiptsRoot,
LogsBloom,
PrevRandao,
BlockNumber,
GasLimit,
GasUsed,
Timestamp,
ExtraData,
BaseFeePerGas,
BlockHash,
Transactions,
// V2
Withdrawals,
// V3
BlobGasUsed,
ExcessBlobGas,
}

let mut parent_hash = None;
let mut fee_recipient = None;
let mut state_root = None;
let mut receipts_root = None;
let mut logs_bloom = None;
let mut prev_randao = None;
let mut block_number = None;
let mut gas_limit = None;
let mut gas_used = None;
let mut timestamp = None;
let mut extra_data = None;
let mut base_fee_per_gas = None;
let mut block_hash = None;
let mut transactions = None;
let mut withdrawals = None;
let mut blob_gas_used = None;
let mut excess_blob_gas = None;

while let Some(key) = map.next_key()? {
match key {
Fields::ParentHash => parent_hash = Some(map.next_value()?),
Fields::FeeRecipient => fee_recipient = Some(map.next_value()?),
Fields::StateRoot => state_root = Some(map.next_value()?),
Fields::ReceiptsRoot => receipts_root = Some(map.next_value()?),
Fields::LogsBloom => logs_bloom = Some(map.next_value()?),
Fields::PrevRandao => prev_randao = Some(map.next_value()?),
Fields::BlockNumber => {
let raw = map.next_value::<&str>()?;
block_number =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
Fields::GasLimit => {
let raw = map.next_value::<&str>()?;
gas_limit =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
Fields::GasUsed => {
let raw = map.next_value::<String>()?;
gas_used =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
Fields::Timestamp => {
let raw = map.next_value::<String>()?;
timestamp =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
Fields::ExtraData => extra_data = Some(map.next_value()?),
Fields::BaseFeePerGas => base_fee_per_gas = Some(map.next_value()?),
Fields::BlockHash => block_hash = Some(map.next_value()?),
Fields::Transactions => transactions = Some(map.next_value()?),
Fields::Withdrawals => withdrawals = Some(map.next_value()?),
Fields::BlobGasUsed => {
let raw = map.next_value::<String>()?;
blob_gas_used =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
Fields::ExcessBlobGas => {
let raw = map.next_value::<String>()?;
excess_blob_gas =
Some(alloy_serde::quantity::deserialize(raw.into_deserializer())?);
}
}
}

let parent_hash =
parent_hash.ok_or_else(|| serde::de::Error::missing_field("parentHash"))?;
let fee_recipient =
fee_recipient.ok_or_else(|| serde::de::Error::missing_field("feeRecipient"))?;
let state_root =
state_root.ok_or_else(|| serde::de::Error::missing_field("stateRoot"))?;
let receipts_root =
receipts_root.ok_or_else(|| serde::de::Error::missing_field("receiptsRoot"))?;
let logs_bloom =
logs_bloom.ok_or_else(|| serde::de::Error::missing_field("logsBloom"))?;
let prev_randao =
prev_randao.ok_or_else(|| serde::de::Error::missing_field("prevRandao"))?;
let block_number =
block_number.ok_or_else(|| serde::de::Error::missing_field("blockNumber"))?;
let gas_limit =
gas_limit.ok_or_else(|| serde::de::Error::missing_field("gasLimit"))?;
let gas_used =
gas_used.ok_or_else(|| serde::de::Error::missing_field("gasUesd"))?;
let timestamp =
timestamp.ok_or_else(|| serde::de::Error::missing_field("timestamp"))?;
let extra_data =
extra_data.ok_or_else(|| serde::de::Error::missing_field("extraData"))?;
let base_fee_per_gas = base_fee_per_gas
.ok_or_else(|| serde::de::Error::missing_field("baseFeePerGas"))?;
let block_hash =
block_hash.ok_or_else(|| serde::de::Error::missing_field("blockHash"))?;
let transactions =
transactions.ok_or_else(|| serde::de::Error::missing_field("transactions"))?;

let v1 = ExecutionPayloadV1 {
parent_hash,
fee_recipient,
state_root,
receipts_root,
logs_bloom,
prev_randao,
block_number,
gas_limit,
gas_used,
timestamp,
extra_data,
base_fee_per_gas,
block_hash,
transactions,
};

let Some(withdrawals) = withdrawals else {
return if blob_gas_used.is_none() && excess_blob_gas.is_none() {
Ok(ExecutionPayload::V1(v1))
} else {
Err(serde::de::Error::custom("invalid enum variant"))
};
};

if let (Some(blob_gas_used), Some(excess_blob_gas)) =
(blob_gas_used, excess_blob_gas)
{
return Ok(ExecutionPayload::V3(ExecutionPayloadV3 {
payload_inner: ExecutionPayloadV2 { payload_inner: v1, withdrawals },
blob_gas_used,
excess_blob_gas,
}));
}

// reject incomplete V3 payloads even if they could construct a valid V2
if blob_gas_used.is_some() || excess_blob_gas.is_some() {
return Err(serde::de::Error::custom("invalid enum variant"));
}

Ok(ExecutionPayload::V2(ExecutionPayloadV2 { payload_inner: v1, withdrawals }))
}
}

const FIELDS: &[&str] = &[
"parentHash",
"feeRecipient",
"stateRoot",
"receiptsRoot",
"logsBloom",
"prevRandao",
"blockNumber",
"gasLimit",
"gasUsed",
"timestamp",
"extraData",
"baseFeePerGas",
"blockHash",
"transactions",
"withdrawals",
"blobGasUsed",
"excessBlobGas",
];
deserializer.deserialize_struct("ExecutionPayload", FIELDS, ExecutionPayloadVisitor)
}
}

Expand Down Expand Up @@ -1479,6 +1664,55 @@ mod tests {
assert_eq!(serde_json::to_string(&envelope).unwrap(), response);
}

#[test]
#[cfg(feature = "serde")]
fn serde_payload_input_enum_v3() {
let response_v3 = r#"{"parentHash":"0xe927a1448525fb5d32cb50ee1408461a945ba6c39bd5cf5621407d500ecc8de9","feeRecipient":"0x0000000000000000000000000000000000000000","stateRoot":"0x10f8a0830000e8edef6d00cc727ff833f064b1950afd591ae41357f97e543119","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prevRandao":"0xe0d8b4521a7da1582a713244ffb6a86aa1726932087386e2dc7973f43fc6cb24","blockNumber":"0x1","gasLimit":"0x2ffbd2","gasUsed":"0x0","timestamp":"0x1235","extraData":"0xd883010d00846765746888676f312e32312e30856c696e7578","baseFeePerGas":"0x342770c0","blockHash":"0x44d0fa5f2f73a938ebb96a2a21679eb8dea3e7b7dd8fd9f35aa756dda8bf0a8a","transactions":[],"withdrawals":[],"blobGasUsed":"0x0","excessBlobGas":"0x0"}"#;

let payload: ExecutionPayload = serde_json::from_str(response_v3).unwrap();
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

can we add roundtrips to all of the tests to ensure that payload serializes into the same serde_json::Value as response_v3

assert!(payload.as_v3().is_some());
assert_eq!(serde_json::to_string(&payload).unwrap(), response_v3);

let payload_v3: ExecutionPayloadV3 = serde_json::from_str(response_v3).unwrap();
assert_eq!(payload.as_v3().unwrap(), &payload_v3);
}

#[test]
#[cfg(feature = "serde")]
fn serde_payload_input_enum_v2() {
let response_v2 = r#"{"parentHash":"0xe927a1448525fb5d32cb50ee1408461a945ba6c39bd5cf5621407d500ecc8de9","feeRecipient":"0x0000000000000000000000000000000000000000","stateRoot":"0x10f8a0830000e8edef6d00cc727ff833f064b1950afd591ae41357f97e543119","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prevRandao":"0xe0d8b4521a7da1582a713244ffb6a86aa1726932087386e2dc7973f43fc6cb24","blockNumber":"0x1","gasLimit":"0x2ffbd2","gasUsed":"0x0","timestamp":"0x1235","extraData":"0xd883010d00846765746888676f312e32312e30856c696e7578","baseFeePerGas":"0x342770c0","blockHash":"0x44d0fa5f2f73a938ebb96a2a21679eb8dea3e7b7dd8fd9f35aa756dda8bf0a8a","transactions":[],"withdrawals":[]}"#;

let payload: ExecutionPayload = serde_json::from_str(response_v2).unwrap();
assert!(payload.as_v3().is_none());
assert!(payload.as_v2().is_some());
assert_eq!(serde_json::to_string(&payload).unwrap(), response_v2);

let payload_v2: ExecutionPayloadV2 = serde_json::from_str(response_v2).unwrap();
assert_eq!(payload.as_v2().unwrap(), &payload_v2);
}

#[test]
#[cfg(feature = "serde")]
fn serde_payload_input_enum_faulty_v2() {
// incomplete V3 payload should be rejected even if it has all V2 fields
let response_faulty = r#"{"parentHash":"0xe927a1448525fb5d32cb50ee1408461a945ba6c39bd5cf5621407d500ecc8de9","feeRecipient":"0x0000000000000000000000000000000000000000","stateRoot":"0x10f8a0830000e8edef6d00cc727ff833f064b1950afd591ae41357f97e543119","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prevRandao":"0xe0d8b4521a7da1582a713244ffb6a86aa1726932087386e2dc7973f43fc6cb24","blockNumber":"0x1","gasLimit":"0x2ffbd2","gasUsed":"0x0","timestamp":"0x1235","extraData":"0xd883010d00846765746888676f312e32312e30856c696e7578","baseFeePerGas":"0x342770c0","blockHash":"0x44d0fa5f2f73a938ebb96a2a21679eb8dea3e7b7dd8fd9f35aa756dda8bf0a8a","transactions":[],"withdrawals":[], "blobGasUsed": "0x0"}"#;

let payload: Result<ExecutionPayload, serde_json::Error> =
serde_json::from_str(response_faulty);
assert!(payload.is_err());
}

#[test]
#[cfg(feature = "serde")]
fn serde_payload_input_enum_faulty_v1() {
// incomplete V3 payload should be rejected even if it has all V1 fields
let response_faulty = r#"{"parentHash":"0xe927a1448525fb5d32cb50ee1408461a945ba6c39bd5cf5621407d500ecc8de9","feeRecipient":"0x0000000000000000000000000000000000000000","stateRoot":"0x10f8a0830000e8edef6d00cc727ff833f064b1950afd591ae41357f97e543119","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prevRandao":"0xe0d8b4521a7da1582a713244ffb6a86aa1726932087386e2dc7973f43fc6cb24","blockNumber":"0x1","gasLimit":"0x2ffbd2","gasUsed":"0x0","timestamp":"0x1235","extraData":"0xd883010d00846765746888676f312e32312e30856c696e7578","baseFeePerGas":"0x342770c0","blockHash":"0x44d0fa5f2f73a938ebb96a2a21679eb8dea3e7b7dd8fd9f35aa756dda8bf0a8a","transactions":[],"blobGasUsed": "0x0"}"#;

let payload: Result<ExecutionPayload, serde_json::Error> =
serde_json::from_str(response_faulty);
assert!(payload.is_err());
}

#[test]
#[cfg(feature = "serde")]
fn serde_faulty_roundtrip_payload_input_v3() {
Expand Down