custom node

fix custom node

tidy

Update lib.rs

Author: rezbera

crates/optimism/rpc/src/lib.rs

@@ -21,6 +21,6 @@ pub mod witness;
 pub use engine::OpEngineApiClient;
 pub use engine::{OpEngineApi, OpEngineApiServer, OP_ENGINE_CAPABILITIES};
 pub use error::{OpEthApiError, OpInvalidTransactionError, SequencerClientError};
-pub use eth::{OpEthApi, OpEthApiBuilder, OpReceiptBuilder};
+pub use eth::{OpEthApi, OpEthApiBuilder, OpReceiptBuilder, OpRpcTypes};
 pub use metrics::SequencerMetrics;
 pub use sequencer::SequencerClient;

examples/custom-node/src/engine.rs

@@ -1,6 +1,7 @@
 use crate::{
     chainspec::CustomChainSpec,
     evm::CustomEvmConfig,
+    flashblock::CustomFlashblockPayload,
     primitives::{CustomHeader, CustomNodePrimitives, CustomTransaction},
     CustomNode,
 };
@@ -67,14 +68,15 @@ impl ExecutionPayload for CustomExecutionData {
     }
 }
 
-impl TryFrom<&reth_optimism_flashblocks::FlashBlockCompleteSequence> for CustomExecutionData {
+impl TryFrom<&reth_optimism_flashblocks::FlashBlockCompleteSequence<CustomFlashblockPayload>>
+    for CustomExecutionData
+{
     type Error = &'static str;
 
     fn try_from(
-        sequence: &reth_optimism_flashblocks::FlashBlockCompleteSequence,
+        _sequence: &reth_optimism_flashblocks::FlashBlockCompleteSequence<CustomFlashblockPayload>,
     ) -> Result<Self, Self::Error> {
-        let inner = OpExecutionData::try_from(sequence)?;
-        Ok(Self { inner, extension: sequence.last().diff.gas_used })
+        todo!("convert flashblock sequence to CustomExecutionData")
     }
 }
 

examples/custom-node/src/evm/config.rs

@@ -2,14 +2,14 @@ use crate::{
     chainspec::CustomChainSpec,
     engine::{CustomExecutionData, CustomPayloadBuilderAttributes},
     evm::{alloy::CustomEvmFactory, executor::CustomBlockExecutionCtx, CustomBlockAssembler},
+    flashblock::CustomFlashblockPayloadBase,
     primitives::{Block, CustomHeader, CustomNodePrimitives, CustomTransaction},
 };
 use alloy_consensus::BlockHeader;
 use alloy_eips::{eip2718::WithEncoded, Decodable2718};
 use alloy_evm::EvmEnv;
 use alloy_op_evm::OpBlockExecutionCtx;
 use alloy_rpc_types_engine::PayloadError;
-use op_alloy_rpc_types_engine::flashblock::OpFlashblockPayloadBase;
 use op_revm::OpSpecId;
 use reth_engine_primitives::ExecutableTxIterator;
 use reth_ethereum::{
@@ -143,9 +143,9 @@ pub struct CustomNextBlockEnvAttributes {
     extension: u64,
 }
 
-impl From<OpFlashblockPayloadBase> for CustomNextBlockEnvAttributes {
-    fn from(value: OpFlashblockPayloadBase) -> Self {
-        Self { inner: value.into(), extension: 0 }
+impl From<CustomFlashblockPayloadBase> for CustomNextBlockEnvAttributes {
+    fn from(_value: CustomFlashblockPayloadBase) -> Self {
+        todo!("map CustomFlashblockPayloadBase fields to CustomNextBlockEnvAttributes")
     }
 }
 

examples/custom-node/src/flashblock.rs

@@ -0,0 +1,121 @@
+use crate::primitives::CustomTransaction;
+use alloy_consensus::{crypto::RecoveryError, transaction::Recovered};
+use alloy_eips::{eip2718::WithEncoded, eip4895::Withdrawals};
+use alloy_primitives::{Bloom, Bytes, B256};
+use alloy_rpc_types_engine::PayloadId;
+use reth_optimism_flashblocks::{FlashblockDiff, FlashblockPayload, FlashblockPayloadBase};
+use serde::{Deserialize, Deserializer};
+
+#[derive(Debug, Clone, Default)]
+pub struct CustomFlashblockPayloadBase {
+    pub parent_hash: B256,
+    pub block_number: u64,
+    pub timestamp: u64,
+}
+
+impl FlashblockPayloadBase for CustomFlashblockPayloadBase {
+    fn parent_hash(&self) -> B256 {
+        self.parent_hash
+    }
+
+    fn block_number(&self) -> u64 {
+        self.block_number
+    }
+
+    fn timestamp(&self) -> u64 {
+        self.timestamp
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct CustomFlashblockPayloadDiff {
+    pub block_hash: B256,
+    pub state_root: B256,
+    pub gas_used: u64,
+    pub logs_bloom: Bloom,
+    pub receipts_root: B256,
+    pub transactions: Vec<Bytes>,
+}
+
+impl FlashblockDiff for CustomFlashblockPayloadDiff {
+    fn block_hash(&self) -> B256 {
+        self.block_hash
+    }
+
+    fn state_root(&self) -> B256 {
+        self.state_root
+    }
+
+    fn gas_used(&self) -> u64 {
+        self.gas_used
+    }
+
+    fn logs_bloom(&self) -> &Bloom {
+        &self.logs_bloom
+    }
+
+    fn receipts_root(&self) -> B256 {
+        self.receipts_root
+    }
+
+    fn transactions_raw(&self) -> &[Bytes] {
+        &self.transactions
+    }
+
+    fn withdrawals(&self) -> Option<&Withdrawals> {
+        None
+    }
+
+    fn withdrawals_root(&self) -> Option<B256> {
+        None
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CustomFlashblockPayload {
+    pub index: u64,
+    pub payload_id: PayloadId,
+    pub base: Option<CustomFlashblockPayloadBase>,
+    pub diff: CustomFlashblockPayloadDiff,
+}
+
+impl<'de> Deserialize<'de> for CustomFlashblockPayload {
+    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        todo!("implement deserialization")
+    }
+}
+
+impl FlashblockPayload for CustomFlashblockPayload {
+    type Base = CustomFlashblockPayloadBase;
+    type Diff = CustomFlashblockPayloadDiff;
+    type SignedTx = CustomTransaction;
+
+    fn index(&self) -> u64 {
+        self.index
+    }
+
+    fn payload_id(&self) -> PayloadId {
+        self.payload_id
+    }
+
+    fn base(&self) -> Option<Self::Base> {
+        self.base.clone()
+    }
+
+    fn diff(&self) -> &Self::Diff {
+        &self.diff
+    }
+
+    fn block_number(&self) -> u64 {
+        self.base.as_ref().map(|b| b.block_number()).unwrap_or(0)
+    }
+
+    fn recover_transactions(
+        &self,
+    ) -> impl Iterator<Item = Result<WithEncoded<Recovered<Self::SignedTx>>, RecoveryError>> {
+        std::iter::from_fn(|| todo!("implement transaction recovery"))
+    }
+}

examples/custom-node/src/lib.rs

@@ -34,6 +34,7 @@ pub mod chainspec;
 pub mod engine;
 pub mod engine_api;
 pub mod evm;
+pub mod flashblock;
 pub mod pool;
 pub mod primitives;
 pub mod rpc;

examples/custom-node/src/rpc.rs

@@ -1,13 +1,14 @@
 use crate::{
     evm::CustomTxEnv,
+    flashblock::CustomFlashblockPayload,
     primitives::{CustomHeader, CustomTransaction},
 };
 use alloy_consensus::error::ValueError;
 use alloy_evm::EvmEnv;
 use alloy_network::TxSigner;
 use op_alloy_consensus::OpTxEnvelope;
 use op_alloy_rpc_types::{OpTransactionReceipt, OpTransactionRequest};
-use reth_op::rpc::RpcTypes;
+use reth_op::rpc::{OpRpcTypes, RpcTypes};
 use reth_rpc_api::eth::{
     EthTxEnvError, SignTxRequestError, SignableTxRequest, TryIntoSimTx, TryIntoTxEnv,
 };
@@ -17,6 +18,10 @@ use revm::context::BlockEnv;
 #[non_exhaustive]
 pub struct CustomRpcTypes;
 
+impl OpRpcTypes for CustomRpcTypes {
+    type Flashblock = CustomFlashblockPayload;
+}
+
 impl RpcTypes for CustomRpcTypes {
     type Header = alloy_rpc_types_eth::Header<CustomHeader>;
     type Receipt = OpTransactionReceipt;