changes (#333)

Author: SozinM

Cargo.lock

@@ -14,6 +14,7 @@ serde_json = "1.0.96"
 metrics = "0.24.0"
 tokio = { version = "1", features = ["full"] }
 eyre = "0.6.12"
+sha2 = { version = "0.10", default-features = false }
 
 # Alloy libraries
 alloy-rpc-types-engine = "1.0.5"

Cargo.toml

@@ -15,6 +15,7 @@ serde_json.workspace = true
 metrics.workspace = true
 tokio.workspace = true
 eyre.workspace = true
+sha2.workspace = true
 
 op-alloy-rpc-types-engine.workspace = true
 alloy-rpc-types-engine.workspace = true

crates/rollup-boost/Cargo.toml

@@ -6,6 +6,7 @@ use crate::RpcClientError;
 use crate::flashblocks::metrics::FlashblocksServiceMetrics;
 use crate::{
     ClientResult, EngineApiExt, NewPayload, OpExecutionPayloadEnvelope, PayloadVersion, RpcClient,
+    payload_id_optimism,
 };
 use alloy_primitives::U256;
 use alloy_rpc_types_engine::{
@@ -296,14 +297,28 @@ impl EngineApiExt for FlashblocksService {
         fork_choice_state: ForkchoiceState,
         payload_attributes: Option<OpPayloadAttributes>,
     ) -> ClientResult<ForkchoiceUpdated> {
+        // Calculate and set expected payload_id
+        if let Some(attr) = &payload_attributes {
+            let payload_id = payload_id_optimism(&fork_choice_state.head_block_hash, attr, 3);
+            self.set_current_payload_id(payload_id).await;
+        }
         let result = self
             .client
             .fork_choice_updated_v3(fork_choice_state, payload_attributes)
             .await?;
 
         if let Some(payload_id) = result.payload_id {
-            tracing::debug!(message = "Forkchoice updated", payload_id = %payload_id);
-            self.set_current_payload_id(payload_id).await;
+            let current_payload = *self.current_payload_id.read().await;
+            if current_payload != payload_id {
+                tracing::error!(
+                    message = "Payload id returned by builder differs from calculated. Using builder payload id",
+                    builder_payload_id = %payload_id,
+                    calculated_payload_id = %current_payload,
+                );
+                self.set_current_payload_id(payload_id).await;
+            } else {
+                tracing::debug!(message = "Forkchoice updated", payload_id = %payload_id);
+            }
         } else {
             tracing::debug!(message = "Forkchoice updated with no payload ID");
         }

crates/rollup-boost/src/flashblocks/service.rs

@@ -1,10 +1,12 @@
-use alloy_primitives::{B256, Bytes};
+use alloy_primitives::private::alloy_rlp::Encodable;
+use alloy_primitives::{B256, Bytes, keccak256};
 use futures::{StreamExt as _, stream};
 use moka::future::Cache;
 
 use alloy_rpc_types_engine::{ExecutionPayload, ExecutionPayloadV3, PayloadId};
 use op_alloy_rpc_types_engine::{
     OpExecutionPayloadEnvelopeV3, OpExecutionPayloadEnvelopeV4, OpExecutionPayloadV4,
+    OpPayloadAttributes,
 };
 
 const CACHE_SIZE: u64 = 100;
@@ -266,3 +268,70 @@ impl PayloadTraceContext {
         }
     }
 }
+
+/// Generates the payload id for the configured payload from the [`OpPayloadAttributes`].
+///
+/// Returns an 8-byte identifier by hashing the payload components with sha256 hash.
+pub(crate) fn payload_id_optimism(
+    parent: &B256,
+    attributes: &OpPayloadAttributes,
+    payload_version: u8,
+) -> PayloadId {
+    use sha2::Digest;
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(parent.as_slice());
+    hasher.update(&attributes.payload_attributes.timestamp.to_be_bytes()[..]);
+    hasher.update(attributes.payload_attributes.prev_randao.as_slice());
+    hasher.update(
+        attributes
+            .payload_attributes
+            .suggested_fee_recipient
+            .as_slice(),
+    );
+    if let Some(withdrawals) = &attributes.payload_attributes.withdrawals {
+        let mut buf = Vec::new();
+        withdrawals.encode(&mut buf);
+        hasher.update(buf);
+    }
+
+    if let Some(parent_beacon_block) = attributes.payload_attributes.parent_beacon_block_root {
+        hasher.update(parent_beacon_block);
+    }
+
+    let no_tx_pool = attributes.no_tx_pool.unwrap_or_default();
+    if no_tx_pool
+        || attributes
+            .transactions
+            .as_ref()
+            .is_some_and(|txs| !txs.is_empty())
+    {
+        hasher.update([no_tx_pool as u8]);
+        let txs_len = attributes
+            .transactions
+            .as_ref()
+            .map(|txs| txs.len())
+            .unwrap_or_default();
+        hasher.update(&txs_len.to_be_bytes()[..]);
+        if let Some(txs) = &attributes.transactions {
+            for tx in txs {
+                // we have to just hash the bytes here because otherwise we would need to decode
+                // the transactions here which really isn't ideal
+                let tx_hash = keccak256(tx);
+                // maybe we can try just taking the hash and not decoding
+                hasher.update(tx_hash)
+            }
+        }
+    }
+
+    if let Some(gas_limit) = attributes.gas_limit {
+        hasher.update(gas_limit.to_be_bytes());
+    }
+
+    if let Some(eip_1559_params) = attributes.eip_1559_params {
+        hasher.update(eip_1559_params.as_slice());
+    }
+
+    let mut out = hasher.finalize();
+    out[0] = payload_version;
+    PayloadId::new(out.as_slice()[..8].try_into().expect("sufficient length"))
+}