mirror of
https://github.com/paradigmxyz/reth.git
synced 2026-02-07 13:35:04 -05:00
808 lines
28 KiB
Rust
808 lines
28 KiB
Rust
//! Optimism Node types config.
|
|
|
|
use crate::{
|
|
args::RollupArgs,
|
|
engine::OpEngineValidator,
|
|
txpool::{OpTransactionPool, OpTransactionValidator},
|
|
OpEngineApiBuilder, OpEngineTypes,
|
|
};
|
|
use op_alloy_consensus::OpPooledTransaction;
|
|
use reth_chainspec::{EthChainSpec, Hardforks};
|
|
use reth_evm::{
|
|
execute::BasicBlockExecutorProvider, ConfigureEvm, ConfigureEvmEnv, ConfigureEvmFor,
|
|
};
|
|
use reth_network::{NetworkConfig, NetworkHandle, NetworkManager, NetworkPrimitives, PeersInfo};
|
|
use reth_node_api::{
|
|
AddOnsContext, FullNodeComponents, KeyHasherTy, NodeAddOns, NodePrimitives, PrimitivesTy, TxTy,
|
|
};
|
|
use reth_node_builder::{
|
|
components::{
|
|
ComponentsBuilder, ConsensusBuilder, ExecutorBuilder, NetworkBuilder,
|
|
PayloadServiceBuilder, PoolBuilder, PoolBuilderConfigOverrides,
|
|
},
|
|
node::{FullNodeTypes, NodeTypes, NodeTypesWithEngine},
|
|
rpc::{EngineValidatorAddOn, EngineValidatorBuilder, RethRpcAddOns, RpcAddOns, RpcHandle},
|
|
BuilderContext, Node, NodeAdapter, NodeComponentsBuilder,
|
|
};
|
|
use reth_optimism_chainspec::OpChainSpec;
|
|
use reth_optimism_consensus::OpBeaconConsensus;
|
|
use reth_optimism_evm::{BasicOpReceiptBuilder, OpEvmConfig};
|
|
use reth_optimism_forks::OpHardforks;
|
|
use reth_optimism_payload_builder::{
|
|
builder::OpPayloadTransactions,
|
|
config::{OpBuilderConfig, OpDAConfig},
|
|
};
|
|
use reth_optimism_primitives::{DepositReceipt, OpPrimitives, OpReceipt, OpTransactionSigned};
|
|
use reth_optimism_rpc::{
|
|
eth::ext::OpEthExtApi,
|
|
miner::{MinerApiExtServer, OpMinerExtApi},
|
|
witness::{DebugExecutionWitnessApiServer, OpDebugWitnessApi},
|
|
OpEthApi, OpEthApiError, SequencerClient,
|
|
};
|
|
use reth_optimism_txpool::conditional::MaybeConditionalTransaction;
|
|
use reth_provider::{providers::ProviderFactoryBuilder, CanonStateSubscriptions, EthStorage};
|
|
use reth_rpc_eth_api::ext::L2EthApiExtServer;
|
|
use reth_rpc_eth_types::error::FromEvmError;
|
|
use reth_rpc_server_types::RethRpcModule;
|
|
use reth_tracing::tracing::{debug, info};
|
|
use reth_transaction_pool::{
|
|
blobstore::DiskFileBlobStore, CoinbaseTipOrdering, EthPoolTransaction, PoolTransaction,
|
|
TransactionPool, TransactionValidationTaskExecutor,
|
|
};
|
|
use reth_trie_db::MerklePatriciaTrie;
|
|
use revm::context::TxEnv;
|
|
use std::sync::Arc;
|
|
|
|
/// Storage implementation for Optimism.
|
|
pub type OpStorage = EthStorage<OpTransactionSigned>;
|
|
|
|
/// Type configuration for a regular Optimism node.
|
|
#[derive(Debug, Default, Clone)]
|
|
#[non_exhaustive]
|
|
pub struct OpNode {
|
|
/// Additional Optimism args
|
|
pub args: RollupArgs,
|
|
/// Data availability configuration for the OP builder.
|
|
///
|
|
/// Used to throttle the size of the data availability payloads (configured by the batcher via
|
|
/// the `miner_` api).
|
|
///
|
|
/// By default no throttling is applied.
|
|
pub da_config: OpDAConfig,
|
|
}
|
|
|
|
impl OpNode {
|
|
/// Creates a new instance of the Optimism node type.
|
|
pub fn new(args: RollupArgs) -> Self {
|
|
Self { args, da_config: OpDAConfig::default() }
|
|
}
|
|
|
|
/// Configure the data availability configuration for the OP builder.
|
|
pub fn with_da_config(mut self, da_config: OpDAConfig) -> Self {
|
|
self.da_config = da_config;
|
|
self
|
|
}
|
|
|
|
/// Returns the components for the given [`RollupArgs`].
|
|
pub fn components<Node>(
|
|
&self,
|
|
) -> ComponentsBuilder<
|
|
Node,
|
|
OpPoolBuilder,
|
|
OpPayloadBuilder,
|
|
OpNetworkBuilder,
|
|
OpExecutorBuilder,
|
|
OpConsensusBuilder,
|
|
>
|
|
where
|
|
Node: FullNodeTypes<
|
|
Types: NodeTypesWithEngine<
|
|
Engine = OpEngineTypes,
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
>,
|
|
>,
|
|
{
|
|
let RollupArgs { disable_txpool_gossip, compute_pending_block, discovery_v4, .. } =
|
|
self.args;
|
|
ComponentsBuilder::default()
|
|
.node_types::<Node>()
|
|
.pool(
|
|
OpPoolBuilder::default()
|
|
.with_enable_tx_conditional(self.args.enable_tx_conditional),
|
|
)
|
|
.payload(
|
|
OpPayloadBuilder::new(compute_pending_block).with_da_config(self.da_config.clone()),
|
|
)
|
|
.network(OpNetworkBuilder {
|
|
disable_txpool_gossip,
|
|
disable_discovery_v4: !discovery_v4,
|
|
})
|
|
.executor(OpExecutorBuilder::default())
|
|
.consensus(OpConsensusBuilder::default())
|
|
}
|
|
|
|
/// Instantiates the [`ProviderFactoryBuilder`] for an opstack node.
|
|
///
|
|
/// # Open a Providerfactory in read-only mode from a datadir
|
|
///
|
|
/// See also: [`ProviderFactoryBuilder`] and
|
|
/// [`ReadOnlyConfig`](reth_provider::providers::ReadOnlyConfig).
|
|
///
|
|
/// ```no_run
|
|
/// use reth_optimism_chainspec::BASE_MAINNET;
|
|
/// use reth_optimism_node::OpNode;
|
|
///
|
|
/// let factory =
|
|
/// OpNode::provider_factory_builder().open_read_only(BASE_MAINNET.clone(), "datadir").unwrap();
|
|
/// ```
|
|
///
|
|
/// # Open a Providerfactory manually with with all required components
|
|
///
|
|
/// ```no_run
|
|
/// use reth_db::open_db_read_only;
|
|
/// use reth_optimism_chainspec::OpChainSpecBuilder;
|
|
/// use reth_optimism_node::OpNode;
|
|
/// use reth_provider::providers::StaticFileProvider;
|
|
/// use std::sync::Arc;
|
|
///
|
|
/// let factory = OpNode::provider_factory_builder()
|
|
/// .db(Arc::new(open_db_read_only("db", Default::default()).unwrap()))
|
|
/// .chainspec(OpChainSpecBuilder::base_mainnet().build().into())
|
|
/// .static_file(StaticFileProvider::read_only("db/static_files", false).unwrap())
|
|
/// .build_provider_factory();
|
|
/// ```
|
|
pub fn provider_factory_builder() -> ProviderFactoryBuilder<Self> {
|
|
ProviderFactoryBuilder::default()
|
|
}
|
|
}
|
|
|
|
impl<N> Node<N> for OpNode
|
|
where
|
|
N: FullNodeTypes<
|
|
Types: NodeTypesWithEngine<
|
|
Engine = OpEngineTypes,
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
Storage = OpStorage,
|
|
>,
|
|
>,
|
|
{
|
|
type ComponentsBuilder = ComponentsBuilder<
|
|
N,
|
|
OpPoolBuilder,
|
|
OpPayloadBuilder,
|
|
OpNetworkBuilder,
|
|
OpExecutorBuilder,
|
|
OpConsensusBuilder,
|
|
>;
|
|
|
|
type AddOns =
|
|
OpAddOns<NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>>;
|
|
|
|
fn components_builder(&self) -> Self::ComponentsBuilder {
|
|
Self::components(self)
|
|
}
|
|
|
|
fn add_ons(&self) -> Self::AddOns {
|
|
Self::AddOns::builder()
|
|
.with_sequencer(self.args.sequencer_http.clone())
|
|
.with_da_config(self.da_config.clone())
|
|
.with_enable_tx_conditional(self.args.enable_tx_conditional)
|
|
.build()
|
|
}
|
|
}
|
|
|
|
impl NodeTypes for OpNode {
|
|
type Primitives = OpPrimitives;
|
|
type ChainSpec = OpChainSpec;
|
|
type StateCommitment = MerklePatriciaTrie;
|
|
type Storage = OpStorage;
|
|
}
|
|
|
|
impl NodeTypesWithEngine for OpNode {
|
|
type Engine = OpEngineTypes;
|
|
}
|
|
|
|
/// Add-ons w.r.t. optimism.
|
|
#[derive(Debug)]
|
|
pub struct OpAddOns<N: FullNodeComponents> {
|
|
/// Rpc add-ons responsible for launching the RPC servers and instantiating the RPC handlers
|
|
/// and eth-api.
|
|
pub rpc_add_ons: RpcAddOns<
|
|
N,
|
|
OpEthApi<N>,
|
|
OpEngineValidatorBuilder,
|
|
OpEngineApiBuilder<OpEngineValidatorBuilder>,
|
|
>,
|
|
/// Data availability configuration for the OP builder.
|
|
pub da_config: OpDAConfig,
|
|
/// Sequencer client, configured to forward submitted transactions to sequencer of given OP
|
|
/// network.
|
|
pub sequencer_client: Option<SequencerClient>,
|
|
/// Enable transaction conditionals.
|
|
enable_tx_conditional: bool,
|
|
}
|
|
|
|
impl<N: FullNodeComponents<Types: NodeTypes<Primitives = OpPrimitives>>> Default for OpAddOns<N> {
|
|
fn default() -> Self {
|
|
Self::builder().build()
|
|
}
|
|
}
|
|
|
|
impl<N: FullNodeComponents<Types: NodeTypes<Primitives = OpPrimitives>>> OpAddOns<N> {
|
|
/// Build a [`OpAddOns`] using [`OpAddOnsBuilder`].
|
|
pub fn builder() -> OpAddOnsBuilder {
|
|
OpAddOnsBuilder::default()
|
|
}
|
|
}
|
|
|
|
impl<N> NodeAddOns<N> for OpAddOns<N>
|
|
where
|
|
N: FullNodeComponents<
|
|
Types: NodeTypesWithEngine<
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
Storage = OpStorage,
|
|
Engine = OpEngineTypes,
|
|
>,
|
|
Evm: ConfigureEvmEnv<TxEnv = revm_optimism::OpTransaction<TxEnv>>,
|
|
>,
|
|
OpEthApiError: FromEvmError<N::Evm>,
|
|
<<N as FullNodeComponents>::Pool as TransactionPool>::Transaction: MaybeConditionalTransaction,
|
|
{
|
|
type Handle = RpcHandle<N, OpEthApi<N>>;
|
|
|
|
async fn launch_add_ons(
|
|
self,
|
|
ctx: reth_node_api::AddOnsContext<'_, N>,
|
|
) -> eyre::Result<Self::Handle> {
|
|
let Self { rpc_add_ons, da_config, sequencer_client, enable_tx_conditional } = self;
|
|
|
|
let builder = reth_optimism_payload_builder::OpPayloadBuilder::new(
|
|
ctx.node.pool().clone(),
|
|
ctx.node.provider().clone(),
|
|
ctx.node.evm_config().clone(),
|
|
BasicOpReceiptBuilder::default(),
|
|
);
|
|
// install additional OP specific rpc methods
|
|
let debug_ext = OpDebugWitnessApi::new(
|
|
ctx.node.provider().clone(),
|
|
Box::new(ctx.node.task_executor().clone()),
|
|
builder,
|
|
);
|
|
let miner_ext = OpMinerExtApi::new(da_config);
|
|
|
|
let tx_conditional_ext: OpEthExtApi<N::Pool, N::Provider> = OpEthExtApi::new(
|
|
sequencer_client,
|
|
ctx.node.pool().clone(),
|
|
ctx.node.provider().clone(),
|
|
);
|
|
rpc_add_ons
|
|
.launch_add_ons_with(ctx, move |modules, auth_modules| {
|
|
debug!(target: "reth::cli", "Installing debug payload witness rpc endpoint");
|
|
modules.merge_if_module_configured(RethRpcModule::Debug, debug_ext.into_rpc())?;
|
|
|
|
// extend the miner namespace if configured in the regular http server
|
|
modules.merge_if_module_configured(
|
|
RethRpcModule::Miner,
|
|
miner_ext.clone().into_rpc(),
|
|
)?;
|
|
|
|
// install the miner extension in the authenticated if configured
|
|
if modules.module_config().contains_any(&RethRpcModule::Miner) {
|
|
debug!(target: "reth::cli", "Installing miner DA rpc enddpoint");
|
|
auth_modules.merge_auth_methods(miner_ext.into_rpc())?;
|
|
}
|
|
|
|
if enable_tx_conditional {
|
|
// extend the eth namespace if configured in the regular http server
|
|
modules.merge_if_module_configured(
|
|
RethRpcModule::Eth,
|
|
tx_conditional_ext.into_rpc(),
|
|
)?;
|
|
}
|
|
|
|
Ok(())
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
|
|
impl<N> RethRpcAddOns<N> for OpAddOns<N>
|
|
where
|
|
N: FullNodeComponents<
|
|
Types: NodeTypesWithEngine<
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
Storage = OpStorage,
|
|
Engine = OpEngineTypes,
|
|
>,
|
|
Evm: ConfigureEvm<TxEnv = revm_optimism::OpTransaction<TxEnv>>,
|
|
>,
|
|
OpEthApiError: FromEvmError<N::Evm>,
|
|
<<N as FullNodeComponents>::Pool as TransactionPool>::Transaction: MaybeConditionalTransaction,
|
|
{
|
|
type EthApi = OpEthApi<N>;
|
|
|
|
fn hooks_mut(&mut self) -> &mut reth_node_builder::rpc::RpcHooks<N, Self::EthApi> {
|
|
self.rpc_add_ons.hooks_mut()
|
|
}
|
|
}
|
|
|
|
impl<N> EngineValidatorAddOn<N> for OpAddOns<N>
|
|
where
|
|
N: FullNodeComponents<
|
|
Types: NodeTypesWithEngine<
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
Engine = OpEngineTypes,
|
|
>,
|
|
>,
|
|
{
|
|
type Validator = OpEngineValidator<N::Provider>;
|
|
|
|
async fn engine_validator(&self, ctx: &AddOnsContext<'_, N>) -> eyre::Result<Self::Validator> {
|
|
OpEngineValidatorBuilder::default().build(ctx).await
|
|
}
|
|
}
|
|
|
|
/// A regular optimism evm and executor builder.
|
|
#[derive(Debug, Default, Clone)]
|
|
#[non_exhaustive]
|
|
pub struct OpAddOnsBuilder {
|
|
/// Sequencer client, configured to forward submitted transactions to sequencer of given OP
|
|
/// network.
|
|
sequencer_client: Option<SequencerClient>,
|
|
/// Data availability configuration for the OP builder.
|
|
da_config: Option<OpDAConfig>,
|
|
/// Enable transaction conditionals.
|
|
enable_tx_conditional: bool,
|
|
}
|
|
|
|
impl OpAddOnsBuilder {
|
|
/// With a [`SequencerClient`].
|
|
pub fn with_sequencer(mut self, sequencer_client: Option<String>) -> Self {
|
|
self.sequencer_client = sequencer_client.map(SequencerClient::new);
|
|
self
|
|
}
|
|
|
|
/// Configure the data availability configuration for the OP builder.
|
|
pub fn with_da_config(mut self, da_config: OpDAConfig) -> Self {
|
|
self.da_config = Some(da_config);
|
|
self
|
|
}
|
|
|
|
/// Configure if transaction conditional should be enabled.
|
|
pub fn with_enable_tx_conditional(mut self, enable_tx_conditional: bool) -> Self {
|
|
self.enable_tx_conditional = enable_tx_conditional;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl OpAddOnsBuilder {
|
|
/// Builds an instance of [`OpAddOns`].
|
|
pub fn build<N>(self) -> OpAddOns<N>
|
|
where
|
|
N: FullNodeComponents<Types: NodeTypes<Primitives = OpPrimitives>>,
|
|
{
|
|
let Self { sequencer_client, da_config, enable_tx_conditional } = self;
|
|
|
|
let sequencer_client_clone = sequencer_client.clone();
|
|
OpAddOns {
|
|
rpc_add_ons: RpcAddOns::new(
|
|
move |ctx| {
|
|
OpEthApi::<N>::builder().with_sequencer(sequencer_client_clone).build(ctx)
|
|
},
|
|
Default::default(),
|
|
Default::default(),
|
|
),
|
|
da_config: da_config.unwrap_or_default(),
|
|
sequencer_client,
|
|
enable_tx_conditional,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A regular optimism evm and executor builder.
|
|
#[derive(Debug, Default, Clone, Copy)]
|
|
#[non_exhaustive]
|
|
pub struct OpExecutorBuilder;
|
|
|
|
impl<Node> ExecutorBuilder<Node> for OpExecutorBuilder
|
|
where
|
|
Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec, Primitives = OpPrimitives>>,
|
|
{
|
|
type EVM = OpEvmConfig;
|
|
type Executor = BasicBlockExecutorProvider<Self::EVM>;
|
|
|
|
async fn build_evm(
|
|
self,
|
|
ctx: &BuilderContext<Node>,
|
|
) -> eyre::Result<(Self::EVM, Self::Executor)> {
|
|
let evm_config = OpEvmConfig::optimism(ctx.chain_spec());
|
|
let executor = BasicBlockExecutorProvider::new(evm_config.clone());
|
|
|
|
Ok((evm_config, executor))
|
|
}
|
|
}
|
|
|
|
/// A basic optimism transaction pool.
|
|
///
|
|
/// This contains various settings that can be configured and take precedence over the node's
|
|
/// config.
|
|
#[derive(Debug, Clone)]
|
|
pub struct OpPoolBuilder<T = crate::txpool::OpPooledTransaction> {
|
|
/// Enforced overrides that are applied to the pool config.
|
|
pub pool_config_overrides: PoolBuilderConfigOverrides,
|
|
/// Enable transaction conditionals.
|
|
pub enable_tx_conditional: bool,
|
|
/// Marker for the pooled transaction type.
|
|
_pd: core::marker::PhantomData<T>,
|
|
}
|
|
|
|
impl<T> Default for OpPoolBuilder<T> {
|
|
fn default() -> Self {
|
|
Self {
|
|
pool_config_overrides: Default::default(),
|
|
enable_tx_conditional: false,
|
|
_pd: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> OpPoolBuilder<T> {
|
|
fn with_enable_tx_conditional(mut self, enable_tx_conditional: bool) -> Self {
|
|
self.enable_tx_conditional = enable_tx_conditional;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<Node, T> PoolBuilder<Node> for OpPoolBuilder<T>
|
|
where
|
|
Node: FullNodeTypes<Types: NodeTypes<ChainSpec: OpHardforks>>,
|
|
T: EthPoolTransaction<Consensus = TxTy<Node::Types>> + MaybeConditionalTransaction,
|
|
{
|
|
type Pool = OpTransactionPool<Node::Provider, DiskFileBlobStore, T>;
|
|
|
|
async fn build_pool(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Pool> {
|
|
let Self { pool_config_overrides, .. } = self;
|
|
let data_dir = ctx.config().datadir();
|
|
let blob_store = DiskFileBlobStore::open(data_dir.blobstore(), Default::default())?;
|
|
|
|
let validator = TransactionValidationTaskExecutor::eth_builder(ctx.provider().clone())
|
|
.no_eip4844()
|
|
.with_head_timestamp(ctx.head().timestamp)
|
|
.kzg_settings(ctx.kzg_settings()?)
|
|
.with_additional_tasks(
|
|
pool_config_overrides
|
|
.additional_validation_tasks
|
|
.unwrap_or_else(|| ctx.config().txpool.additional_validation_tasks),
|
|
)
|
|
.build_with_tasks(ctx.task_executor().clone(), blob_store.clone())
|
|
.map(|validator| {
|
|
OpTransactionValidator::new(validator)
|
|
// In --dev mode we can't require gas fees because we're unable to decode
|
|
// the L1 block info
|
|
.require_l1_data_gas_fee(!ctx.config().dev.dev)
|
|
});
|
|
|
|
let transaction_pool = reth_transaction_pool::Pool::new(
|
|
validator,
|
|
CoinbaseTipOrdering::default(),
|
|
blob_store,
|
|
pool_config_overrides.apply(ctx.pool_config()),
|
|
);
|
|
info!(target: "reth::cli", "Transaction pool initialized");
|
|
let transactions_path = data_dir.txpool_transactions();
|
|
|
|
// spawn txpool maintenance tasks
|
|
{
|
|
let pool = transaction_pool.clone();
|
|
let chain_events = ctx.provider().canonical_state_stream();
|
|
let client = ctx.provider().clone();
|
|
let transactions_backup_config =
|
|
reth_transaction_pool::maintain::LocalTransactionBackupConfig::with_local_txs_backup(transactions_path);
|
|
|
|
ctx.task_executor().spawn_critical_with_graceful_shutdown_signal(
|
|
"local transactions backup task",
|
|
|shutdown| {
|
|
reth_transaction_pool::maintain::backup_local_transactions_task(
|
|
shutdown,
|
|
pool.clone(),
|
|
transactions_backup_config,
|
|
)
|
|
},
|
|
);
|
|
|
|
// spawn the main maintenance task
|
|
ctx.task_executor().spawn_critical(
|
|
"txpool maintenance task",
|
|
reth_transaction_pool::maintain::maintain_transaction_pool_future(
|
|
client,
|
|
pool.clone(),
|
|
chain_events,
|
|
ctx.task_executor().clone(),
|
|
Default::default(),
|
|
),
|
|
);
|
|
debug!(target: "reth::cli", "Spawned txpool maintenance task");
|
|
|
|
if self.enable_tx_conditional {
|
|
// spawn the Op txpool maintenance task
|
|
let chain_events = ctx.provider().canonical_state_stream();
|
|
ctx.task_executor().spawn_critical(
|
|
"Op txpool maintenance task",
|
|
reth_optimism_txpool::maintain::maintain_transaction_pool_future(
|
|
pool,
|
|
chain_events,
|
|
),
|
|
);
|
|
debug!(target: "reth::cli", "Spawned Op txpool maintenance task");
|
|
}
|
|
}
|
|
|
|
Ok(transaction_pool)
|
|
}
|
|
}
|
|
|
|
/// A basic optimism payload service builder
|
|
#[derive(Debug, Default, Clone)]
|
|
pub struct OpPayloadBuilder<Txs = ()> {
|
|
/// By default the pending block equals the latest block
|
|
/// to save resources and not leak txs from the tx-pool,
|
|
/// this flag enables computing of the pending block
|
|
/// from the tx-pool instead.
|
|
///
|
|
/// If `compute_pending_block` is not enabled, the payload builder
|
|
/// will use the payload attributes from the latest block. Note
|
|
/// that this flag is not yet functional.
|
|
pub compute_pending_block: bool,
|
|
/// The type responsible for yielding the best transactions for the payload if mempool
|
|
/// transactions are allowed.
|
|
pub best_transactions: Txs,
|
|
/// This data availability configuration specifies constraints for the payload builder
|
|
/// when assembling payloads
|
|
pub da_config: OpDAConfig,
|
|
}
|
|
|
|
impl OpPayloadBuilder {
|
|
/// Create a new instance with the given `compute_pending_block` flag and data availability
|
|
/// config.
|
|
pub fn new(compute_pending_block: bool) -> Self {
|
|
Self { compute_pending_block, best_transactions: (), da_config: OpDAConfig::default() }
|
|
}
|
|
|
|
/// Configure the data availability configuration for the OP payload builder.
|
|
pub fn with_da_config(mut self, da_config: OpDAConfig) -> Self {
|
|
self.da_config = da_config;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<Txs> OpPayloadBuilder<Txs> {
|
|
/// Configures the type responsible for yielding the transactions that should be included in the
|
|
/// payload.
|
|
pub fn with_transactions<T>(self, best_transactions: T) -> OpPayloadBuilder<T> {
|
|
let Self { compute_pending_block, da_config, .. } = self;
|
|
OpPayloadBuilder { compute_pending_block, best_transactions, da_config }
|
|
}
|
|
|
|
/// A helper method to initialize [`reth_optimism_payload_builder::OpPayloadBuilder`] with the
|
|
/// given EVM config.
|
|
#[expect(clippy::type_complexity)]
|
|
pub fn build<Node, Evm, Pool>(
|
|
&self,
|
|
evm_config: Evm,
|
|
ctx: &BuilderContext<Node>,
|
|
pool: Pool,
|
|
) -> eyre::Result<
|
|
reth_optimism_payload_builder::OpPayloadBuilder<
|
|
Pool,
|
|
Node::Provider,
|
|
Evm,
|
|
PrimitivesTy<Node::Types>,
|
|
Txs,
|
|
>,
|
|
>
|
|
where
|
|
Node: FullNodeTypes<
|
|
Types: NodeTypesWithEngine<
|
|
Engine = OpEngineTypes,
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
>,
|
|
>,
|
|
Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>>
|
|
+ Unpin
|
|
+ 'static,
|
|
Evm: ConfigureEvmFor<PrimitivesTy<Node::Types>>,
|
|
Txs: OpPayloadTransactions<Pool::Transaction>,
|
|
{
|
|
let payload_builder = reth_optimism_payload_builder::OpPayloadBuilder::with_builder_config(
|
|
pool,
|
|
ctx.provider().clone(),
|
|
evm_config,
|
|
BasicOpReceiptBuilder::default(),
|
|
OpBuilderConfig { da_config: self.da_config.clone() },
|
|
)
|
|
.with_transactions(self.best_transactions.clone())
|
|
.set_compute_pending_block(self.compute_pending_block);
|
|
Ok(payload_builder)
|
|
}
|
|
}
|
|
|
|
impl<Node, Pool, Txs> PayloadServiceBuilder<Node, Pool> for OpPayloadBuilder<Txs>
|
|
where
|
|
Node: FullNodeTypes<
|
|
Types: NodeTypesWithEngine<
|
|
Engine = OpEngineTypes,
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
>,
|
|
>,
|
|
Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>>
|
|
+ Unpin
|
|
+ 'static,
|
|
Txs: OpPayloadTransactions<Pool::Transaction>,
|
|
{
|
|
type PayloadBuilder = reth_optimism_payload_builder::OpPayloadBuilder<
|
|
Pool,
|
|
Node::Provider,
|
|
OpEvmConfig,
|
|
PrimitivesTy<Node::Types>,
|
|
Txs,
|
|
>;
|
|
|
|
async fn build_payload_builder(
|
|
&self,
|
|
ctx: &BuilderContext<Node>,
|
|
pool: Pool,
|
|
) -> eyre::Result<Self::PayloadBuilder> {
|
|
self.build(OpEvmConfig::optimism(ctx.chain_spec()), ctx, pool)
|
|
}
|
|
}
|
|
|
|
/// A basic optimism network builder.
|
|
#[derive(Debug, Default, Clone)]
|
|
pub struct OpNetworkBuilder {
|
|
/// Disable transaction pool gossip
|
|
pub disable_txpool_gossip: bool,
|
|
/// Disable discovery v4
|
|
pub disable_discovery_v4: bool,
|
|
}
|
|
|
|
impl OpNetworkBuilder {
|
|
/// Returns the [`NetworkConfig`] that contains the settings to launch the p2p network.
|
|
///
|
|
/// This applies the configured [`OpNetworkBuilder`] settings.
|
|
pub fn network_config<Node>(
|
|
&self,
|
|
ctx: &BuilderContext<Node>,
|
|
) -> eyre::Result<NetworkConfig<<Node as FullNodeTypes>::Provider, OpNetworkPrimitives>>
|
|
where
|
|
Node: FullNodeTypes<Types: NodeTypes<ChainSpec: Hardforks>>,
|
|
{
|
|
let Self { disable_txpool_gossip, disable_discovery_v4 } = self.clone();
|
|
let args = &ctx.config().network;
|
|
let network_builder = ctx
|
|
.network_config_builder()?
|
|
// apply discovery settings
|
|
.apply(|mut builder| {
|
|
let rlpx_socket = (args.addr, args.port).into();
|
|
if disable_discovery_v4 || args.discovery.disable_discovery {
|
|
builder = builder.disable_discv4_discovery();
|
|
}
|
|
if !args.discovery.disable_discovery {
|
|
builder = builder.discovery_v5(
|
|
args.discovery.discovery_v5_builder(
|
|
rlpx_socket,
|
|
ctx.config()
|
|
.network
|
|
.resolved_bootnodes()
|
|
.or_else(|| ctx.chain_spec().bootnodes())
|
|
.unwrap_or_default(),
|
|
),
|
|
);
|
|
}
|
|
|
|
builder
|
|
});
|
|
|
|
let mut network_config = ctx.build_network_config(network_builder);
|
|
|
|
// When `sequencer_endpoint` is configured, the node will forward all transactions to a
|
|
// Sequencer node for execution and inclusion on L1, and disable its own txpool
|
|
// gossip to prevent other parties in the network from learning about them.
|
|
network_config.tx_gossip_disabled = disable_txpool_gossip;
|
|
|
|
Ok(network_config)
|
|
}
|
|
}
|
|
|
|
impl<Node, Pool> NetworkBuilder<Node, Pool> for OpNetworkBuilder
|
|
where
|
|
Node: FullNodeTypes<Types: NodeTypes<ChainSpec = OpChainSpec, Primitives = OpPrimitives>>,
|
|
Pool: TransactionPool<
|
|
Transaction: PoolTransaction<
|
|
Consensus = TxTy<Node::Types>,
|
|
Pooled = OpPooledTransaction,
|
|
>,
|
|
> + Unpin
|
|
+ 'static,
|
|
{
|
|
type Primitives = OpNetworkPrimitives;
|
|
|
|
async fn build_network(
|
|
self,
|
|
ctx: &BuilderContext<Node>,
|
|
pool: Pool,
|
|
) -> eyre::Result<NetworkHandle<Self::Primitives>> {
|
|
let network_config = self.network_config(ctx)?;
|
|
let network = NetworkManager::builder(network_config).await?;
|
|
let handle = ctx.start_network(network, pool);
|
|
info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking initialized");
|
|
|
|
Ok(handle)
|
|
}
|
|
}
|
|
|
|
/// A basic optimism consensus builder.
|
|
#[derive(Debug, Default, Clone)]
|
|
#[non_exhaustive]
|
|
pub struct OpConsensusBuilder;
|
|
|
|
impl<Node> ConsensusBuilder<Node> for OpConsensusBuilder
|
|
where
|
|
Node: FullNodeTypes<
|
|
Types: NodeTypes<
|
|
ChainSpec: OpHardforks,
|
|
Primitives: NodePrimitives<Receipt: DepositReceipt>,
|
|
>,
|
|
>,
|
|
{
|
|
type Consensus = Arc<OpBeaconConsensus<<Node::Types as NodeTypes>::ChainSpec>>;
|
|
|
|
async fn build_consensus(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Consensus> {
|
|
Ok(Arc::new(OpBeaconConsensus::new(ctx.chain_spec())))
|
|
}
|
|
}
|
|
|
|
/// Builder for [`OpEngineValidator`].
|
|
#[derive(Debug, Default, Clone)]
|
|
#[non_exhaustive]
|
|
pub struct OpEngineValidatorBuilder;
|
|
|
|
impl<Node, Types> EngineValidatorBuilder<Node> for OpEngineValidatorBuilder
|
|
where
|
|
Types: NodeTypesWithEngine<
|
|
ChainSpec = OpChainSpec,
|
|
Primitives = OpPrimitives,
|
|
Engine = OpEngineTypes,
|
|
>,
|
|
Node: FullNodeComponents<Types = Types>,
|
|
{
|
|
type Validator = OpEngineValidator<Node::Provider>;
|
|
|
|
async fn build(self, ctx: &AddOnsContext<'_, Node>) -> eyre::Result<Self::Validator> {
|
|
Ok(OpEngineValidator::new::<KeyHasherTy<Types>>(
|
|
ctx.config.chain.clone(),
|
|
ctx.node.provider().clone(),
|
|
))
|
|
}
|
|
}
|
|
|
|
/// Network primitive types used by Optimism networks.
|
|
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
|
|
#[non_exhaustive]
|
|
pub struct OpNetworkPrimitives;
|
|
|
|
impl NetworkPrimitives for OpNetworkPrimitives {
|
|
type BlockHeader = alloy_consensus::Header;
|
|
type BlockBody = reth_primitives::BlockBody<OpTransactionSigned>;
|
|
type Block = reth_primitives::Block<OpTransactionSigned>;
|
|
type BroadcastedTransaction = OpTransactionSigned;
|
|
type PooledTransaction = OpPooledTransaction;
|
|
type Receipt = OpReceipt;
|
|
}
|