chore: new hash_block method added on network trait + ethreum and ops…

…tack crate updated

cli/src/main.rs

@@ -61,18 +61,14 @@ fn enable_tracer() {
     tracing::subscriber::set_global_default(subscriber).expect("subscriber set failed");
 }
 
-async fn start_client<N: NetworkSpec, C: Consensus<N::TransactionResponse>>(
-    client: &mut Client<N, C>,
-) {
+async fn start_client<N: NetworkSpec, C: Consensus<N::BlockResponse>>(client: &mut Client<N, C>) {
     if let Err(err) = client.start().await {
         error!(target: "helios::runner", error = %err);
         exit(1);
     }
 }
 
-fn register_shutdown_handler<N: NetworkSpec, C: Consensus<N::TransactionResponse>>(
-    client: Client<N, C>,
-) {
+fn register_shutdown_handler<N: NetworkSpec, C: Consensus<N::BlockResponse>>(client: Client<N, C>) {
     let client = Arc::new(client);
     let shutdown_counter = Arc::new(Mutex::new(0));
 

core/src/execution/state.rs

@@ -327,7 +327,7 @@ impl<N: NetworkSpec, R: ExecutionRpc<N>> Inner<N, R> {
             if self.blocks.get(&prev).is_none() {
                 let backfilled = self.rpc.get_block(block.header().parent_hash()).await?;
 
-                if backfilled.is_hash_valid()
+                if N::hash_block(&backfilled) == backfilled.header().hash()
                     && block.header().parent_hash() == backfilled.header().hash()
                 {
                     info!("backfilled: block={}", backfilled.header().number());

core/src/network_spec.rs

@@ -1,8 +1,9 @@
-use alloy::{network::Network, rpc::types::Log};
+use alloy::{network::Network, primitives::B256, rpc::types::Log};
 use revm::primitives::{BlockEnv, TxEnv};
 
 pub trait NetworkSpec: Network {
     fn encode_receipt(receipt: &Self::ReceiptResponse) -> Vec<u8>;
+    fn hash_block(block: &Self::BlockResponse) -> B256;
     fn receipt_contains(list: &[Self::ReceiptResponse], elem: &Self::ReceiptResponse) -> bool;
     fn receipt_logs(receipt: &Self::ReceiptResponse) -> Vec<Log>;
     fn tx_env(request: &Self::TransactionRequest) -> TxEnv;

ethereum/src/consensus.rs

@@ -2,8 +2,8 @@ use std::marker::PhantomData;
 use std::process;
 use std::sync::Arc;
 
-use alloy::consensus::{Header as ConsensusHeader, Sealed, Transaction as TxTrait, TxEnvelope};
-use alloy::primitives::{b256, fixed_bytes, B256, U256, U64};
+use alloy::consensus::{Header as ConsensusHeader, Transaction as TxTrait, TxEnvelope};
+use alloy::primitives::{b256, fixed_bytes, Bloom, BloomInput, B256, U256};
 use alloy::rlp::{encode, Decodable};
 use alloy::rpc::types::{Block, BlockTransactions, Header, Transaction};
 use chrono::Duration;
@@ -59,7 +59,7 @@ pub struct Inner<S: ConsensusSpec, R: ConsensusRpc<S>> {
     phantom: PhantomData<S>,
 }
 
-impl<S: ConsensusSpec, R: ConsensusRpc<S>, DB: Database> Consensus<Transaction>
+impl<S: ConsensusSpec, R: ConsensusRpc<S>, DB: Database> Consensus<Block>
     for ConsensusClient<S, R, DB>
 {
     fn block_recv(&mut self) -> Option<Receiver<Block<Transaction>>> {
@@ -607,36 +607,40 @@ fn payload_to_block<S: ConsensusSpec>(value: ExecutionPayload<S>) -> Block<Trans
 
     let withdrawals = value.withdrawals().unwrap().iter().map(encode);
     let withdrawals_root = ordered_trie_root(withdrawals);
+    let logs_bloom: Bloom =
+        Bloom::from(BloomInput::Raw(&value.logs_bloom().clone().inner.to_vec()));
 
     let consensus_header = ConsensusHeader {
-        parent_hash: *value.block_hash(),
+        parent_hash: *value.parent_hash(),
         ommers_hash: empty_uncle_hash,
         beneficiary: *value.fee_recipient(),
         state_root: *value.state_root(),
         transactions_root: B256::from_slice(txs_root.as_bytes()),
         receipts_root: *value.receipts_root(),
         withdrawals_root: Some(B256::from_slice(withdrawals_root.as_bytes())),
-        logs_bloom: value.logs_bloom().inner.to_vec().into(),
+        logs_bloom: logs_bloom,
         difficulty: U256::ZERO,
         number: *value.block_number(),
         gas_limit: *value.gas_limit(),
         gas_used: *value.gas_used(),
         timestamp: *value.timestamp(),
         mix_hash: *value.prev_randao(),
         nonce: empty_nonce,
-        base_fee_per_gas: Some(*value.base_fee_per_gas().into()),
+        base_fee_per_gas: Some(value.base_fee_per_gas().to::<u64>()),
         blob_gas_used: value.blob_gas_used().cloned().ok(),
         excess_blob_gas: value.excess_blob_gas().cloned().ok(),
-        parent_beacon_block_root: Some(*value.parent_hash()),
+        parent_beacon_block_root: None,
         extra_data: value.extra_data().inner.to_vec().into(),
         requests_hash: None,
     };
 
-    let header = Header::from_consensus(
-        Sealed::new(consensus_header),
-        Some(U256::ZERO),
-        Some(U256::ZERO),
-    );
+    let header = Header {
+        hash: *value.block_hash(),
+        inner: consensus_header,
+        total_difficulty: Some(U256::ZERO),
+        size: Some(U256::ZERO),
+    };
+
     Block::new(header, BlockTransactions::Full(txs))
 }
 

ethereum/src/spec.rs

@@ -1,5 +1,5 @@
 use alloy::{
-    consensus::{Receipt, ReceiptWithBloom, TxReceipt, TxType, TypedTransaction},
+    consensus::{BlockHeader, Receipt, ReceiptWithBloom, TxReceipt, TxType, TypedTransaction},
     network::{BuildResult, Network, NetworkWallet, TransactionBuilder, TransactionBuilderError},
     primitives::{Address, Bytes, ChainId, TxKind, U256},
     rpc::types::{AccessList, Log, TransactionRequest},
@@ -36,6 +36,10 @@ impl NetworkSpec for Ethereum {
         }
     }
 
+    fn hash_block(block: &Self::BlockResponse) -> revm::primitives::B256 {
+        block.header.hash_slow()
+    }
+
     fn receipt_contains(list: &[Self::ReceiptResponse], elem: &Self::ReceiptResponse) -> bool {
         for receipt in list {
             if receipt == elem {
@@ -85,17 +89,17 @@ impl NetworkSpec for Ethereum {
 
     fn block_env(block: &Self::BlockResponse) -> BlockEnv {
         let mut block_env = BlockEnv::default();
-        block_env.number = block.header.number();
+        block_env.number = U256::from(block.header.number());
         block_env.coinbase = block.header.beneficiary();
-        block_env.timestamp = block.header.timestamp();
-        block_env.gas_limit = block.header.gas_limit();
-        block_env.basefee = block.header.base_fee_per_gas();
+        block_env.timestamp = U256::from(block.header.timestamp());
+        block_env.gas_limit = U256::from(block.header.gas_limit());
+        block_env.basefee = U256::from(block.header.base_fee_per_gas().unwrap_or(0_u64));
         block_env.difficulty = block.header.difficulty();
-        block_env.prevrandao = Some(block.header.mix_hash());
+        block_env.prevrandao = block.header.mix_hash();
         block_env.blob_excess_gas_and_price = block
             .header
             .excess_blob_gas()
-            .map(|v| BlobExcessGasAndPrice::new(v.to()));
+            .map(|v| BlobExcessGasAndPrice::new(v.into()));
 
         block_env
     }

ethereum/tests/sync.rs

@@ -27,5 +27,5 @@ async fn test_sync() {
     let client = setup().await;
 
     let block = client.block_recv.unwrap().recv().await.unwrap();
-    assert_eq!(block.number.to::<u64>(), 17923112);
+    assert_eq!(block.header.number, 17923112_u64);
 }

opstack/src/consensus.rs

@@ -1,12 +1,13 @@
 use alloy::consensus::{Header as ConsensusHeader, Transaction as TxTrait};
-use alloy::primitives::{b256, fixed_bytes, keccak256, Address, B256, U256, U64};
+use alloy::primitives::{b256, fixed_bytes, keccak256, Address, Bloom, BloomInput, B256, U256};
 use alloy::rlp::Decodable;
 use alloy::rpc::types::{
     Block, EIP1186AccountProofResponse, Header, Transaction as EthTransaction,
 };
 use alloy_rlp::encode;
 use eyre::{eyre, OptionExt, Result};
 use op_alloy_consensus::OpTxEnvelope;
+use op_alloy_network::primitives::BlockTransactions;
 use op_alloy_rpc_types::Transaction;
 use std::str::FromStr;
 use std::time::Duration;
@@ -82,7 +83,7 @@ impl ConsensusClient {
     }
 }
 
-impl Consensus<Transaction> for ConsensusClient {
+impl Consensus<Block<Transaction>> for ConsensusClient {
     fn chain_id(&self) -> u64 {
         self.chain_id
     }
@@ -142,7 +143,7 @@ impl Inner {
                 let number = payload.block_number;
 
                 if let Ok(block) = payload_to_block(payload) {
-                    self.latest_block = Some(block.number.to());
+                    self.latest_block = Some(block.header.number);
                     _ = self.block_send.send(block).await;
 
                     tracing::info!(
@@ -193,7 +194,10 @@ fn verify_unsafe_signer(config: Config, signer: Arc<Mutex<Address>>) {
                 .ok_or_eyre("failed to receive block")?;
 
             // Query proof from op consensus server
-            let req = format!("{}unsafe_signer_proof/{}", config.consensus_rpc, block.hash);
+            let req = format!(
+                "{}unsafe_signer_proof/{}",
+                config.consensus_rpc, block.header.hash
+            );
             let proof = reqwest::get(req)
                 .await?
                 .json::<EIP1186AccountProofResponse>()
@@ -205,7 +209,7 @@ fn verify_unsafe_signer(config: Config, signer: Arc<Mutex<Address>>) {
             let account_encoded = encode_account(&proof);
             let is_valid = verify_proof(
                 &proof.account_proof,
-                block.state_root.as_slice(),
+                block.header.state_root.as_slice(),
                 &account_path,
                 &account_encoded,
             );
@@ -340,36 +344,38 @@ fn payload_to_block(value: ExecutionPayload) -> Result<Block<Transaction>> {
 
     let withdrawals = value.withdrawals.iter().map(|v| encode(v));
     let withdrawals_root = ordered_trie_root(withdrawals);
+    let logs_bloom: Bloom = Bloom::from(BloomInput::Raw(&value.logs_bloom.to_vec()));
 
     let consensus_header = ConsensusHeader {
-        parent_hash: *value.block_hash(),
+        parent_hash: value.parent_hash.into(),
         ommers_hash: empty_uncle_hash,
-        beneficiary: *value.fee_recipient(),
-        state_root: *value.state_root(),
+        beneficiary: Address::from(*value.fee_recipient),
+        state_root: value.state_root.into(),
         transactions_root: B256::from_slice(txs_root.as_bytes()),
-        receipts_root: *value.receipts_root(),
+        receipts_root: value.receipts_root.into(),
         withdrawals_root: Some(B256::from_slice(withdrawals_root.as_bytes())),
-        logs_bloom: value.logs_bloom().inner.to_vec().into(),
+        logs_bloom: logs_bloom,
         difficulty: U256::ZERO,
-        number: *value.block_number(),
-        gas_limit: *value.gas_limit(),
-        gas_used: *value.gas_used(),
-        timestamp: *value.timestamp(),
-        mix_hash: *value.prev_randao(),
+        number: value.block_number,
+        gas_limit: value.gas_limit,
+        gas_used: value.gas_used,
+        timestamp: value.timestamp,
+        mix_hash: value.prev_randao.into(),
         nonce: empty_nonce,
-        base_fee_per_gas: Some(*value.base_fee_per_gas().into()),
-        blob_gas_used: value.blob_gas_used().cloned().ok(),
-        excess_blob_gas: value.excess_blob_gas().cloned().ok(),
-        parent_beacon_block_root: Some(*value.parent_hash()),
-        extra_data: value.extra_data().inner.to_vec().into(),
+        base_fee_per_gas: Some(value.base_fee_per_gas.to::<u64>()),
+        blob_gas_used: Some(value.blob_gas_used),
+        excess_blob_gas: Some(value.excess_blob_gas),
+        parent_beacon_block_root: None,
+        extra_data: value.extra_data.to_vec().into(),
         requests_hash: None,
     };
 
-    let header = Header::from_consensus(
-        Sealed::new(consensus_header),
-        Some(U256::ZERO),
-        Some(U256::ZERO),
-    );
+    let header = Header {
+        hash: value.block_hash,
+        inner: consensus_header,
+        total_difficulty: Some(U256::ZERO),
+        size: Some(U256::ZERO),
+    };
 
     Ok(Block::new(header, BlockTransactions::Full(txs)))
 }

opstack/src/spec.rs

@@ -1,5 +1,7 @@
 use alloy::{
-    consensus::{Receipt, ReceiptWithBloom, Transaction as TxTrait, TxReceipt, TxType},
+    consensus::{
+        BlockHeader, Receipt, ReceiptWithBloom, Transaction as TxTrait, TxReceipt, TxType,
+    },
     primitives::{Address, Bytes, ChainId, TxKind, U256},
     rpc::types::{AccessList, Log, TransactionRequest},
 };
@@ -67,6 +69,10 @@ impl NetworkSpec for OpStack {
         }
     }
 
+    fn hash_block(block: &Self::BlockResponse) -> revm::primitives::B256 {
+        block.header.hash_slow()
+    }
+
     fn receipt_contains(list: &[Self::ReceiptResponse], elem: &Self::ReceiptResponse) -> bool {
         for receipt in list {
             if receipt == elem {
@@ -122,17 +128,17 @@ impl NetworkSpec for OpStack {
 
     fn block_env(block: &Self::BlockResponse) -> BlockEnv {
         let mut block_env = BlockEnv::default();
-        block_env.number = block.header.number();
+        block_env.number = U256::from(block.header.number());
         block_env.coinbase = block.header.beneficiary();
-        block_env.timestamp = block.header.timestamp();
-        block_env.gas_limit = block.header.gas_limit();
-        block_env.basefee = block.header.base_fee_per_gas();
+        block_env.timestamp = U256::from(block.header.timestamp());
+        block_env.gas_limit = U256::from(block.header.gas_limit());
+        block_env.basefee = U256::from(block.header.base_fee_per_gas().unwrap_or(0_u64));
         block_env.difficulty = block.header.difficulty();
-        block_env.prevrandao = Some(block.header.mix_hash());
+        block_env.prevrandao = block.header.mix_hash();
         block_env.blob_excess_gas_and_price = block
             .header
             .excess_blob_gas()
-            .map(|v| BlobExcessGasAndPrice::new(v.to()));
+            .map(|v| BlobExcessGasAndPrice::new(v.into()));
 
         block_env
     }