Seismic-Reth fork diff

diff --git reth/crates/seismic/evm/Cargo.toml seismic-reth/crates/seismic/evm/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..98bb7d6efc976da720325bb514b1ccebabc437cd --- /dev/null +++ seismic-reth/crates/seismic/evm/Cargo.toml @@ -0,0 +1,97 @@ +[package] +name = "reth-seismic-evm" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +# seismic +seismic-enclave.workspace = true +seismic-alloy-genesis.workspace = true + +# Reth +reth-chainspec.workspace = true +reth-ethereum-forks.workspace = true +reth-evm = { workspace = true } +reth-primitives-traits.workspace = true +reth-execution-errors.workspace = true +reth-execution-types.workspace = true +reth-storage-errors.workspace = true +reth-consensus.workspace = true +reth-consensus-common.workspace = true + +# ethereum +alloy-eips.workspace = true +alloy-evm.workspace = true +alloy-seismic-evm.workspace = true +alloy-primitives.workspace = true +alloy-rpc-types-engine.workspace = true +seismic-alloy-consensus.workspace = true +alloy-consensus.workspace = true + +reth-seismic-chainspec.workspace = true +reth-seismic-forks.workspace = true +reth-seismic-primitives = { workspace = true } +reth-ethereum-primitives = { workspace = true, features = ["serde", "serde-bincode-compat", "reth-codec"]} + +# revm +revm = { workspace = true} +seismic-revm.workspace = true + +# misc +derive_more.workspace = true +tracing.workspace = true +thiserror.workspace = true +schnorrkel.workspace = true + +[dev-dependencies] +reth-evm = { workspace = true, features = ["test-utils"] } +reth-revm = { workspace = true, features = ["test-utils"] } +reth-seismic-chainspec.workspace = true +alloy-genesis.workspace = true +alloy-consensus.workspace = true +reth-seismic-primitives = { workspace = true, features = ["arbitrary"] } +reth-testing-utils.workspace = true +secp256k1.workspace = true +revm-state.workspace = true +k256.workspace = true + +[features] +default = ["std"] +timestamp-in-seconds = [ + "revm/timestamp-in-seconds", + "seismic-revm/timestamp-in-seconds", + "reth-seismic-chainspec/timestamp-in-seconds", + "alloy-evm/timestamp-in-seconds", + "alloy-seismic-evm/timestamp-in-seconds" +] +std = [ + "reth-consensus/std", + "reth-revm/std", + "alloy-consensus/std", + "alloy-eips/std", + "alloy-genesis/std", + "alloy-primitives/std", + "reth-primitives-traits/std", + "revm/std", + "reth-seismic-primitives/std", + "reth-ethereum-forks/std", + "derive_more/std", + "thiserror/std", + "seismic-alloy-consensus/std", + "reth-chainspec/std", + "reth-consensus-common/std", + "reth-seismic-chainspec/std", + "reth-execution-errors/std", + "reth-execution-types/std", + "alloy-evm/std", + "reth-evm/std", + "tracing/std", +] +portable = ["reth-revm/portable"]

diff --git reth/crates/seismic/evm/src/build.rs seismic-reth/crates/seismic/evm/src/build.rs new file mode 100644 index 0000000000000000000000000000000000000000..29e9e4a97361d743d3893f8a6b65a10f4eeeb8bc --- /dev/null +++ seismic-reth/crates/seismic/evm/src/build.rs @@ -0,0 +1,135 @@ +//! The `SeismicBlockAssembler`. Nearly identical to the `EthBlockAssembler`, except with seismic +//! types + +use alloc::sync::Arc; +use alloy_consensus::{ + proofs, Block, BlockBody, BlockHeader, Header, Transaction, TxReceipt, EMPTY_OMMER_ROOT_HASH, +}; +use alloy_eips::merge::BEACON_NONCE; +use alloy_evm::block::BlockExecutorFactory; +use alloy_primitives::{logs_bloom, Bytes}; +use reth_chainspec::{EthChainSpec, EthereumHardforks}; +use reth_evm::{ + eth::EthBlockExecutionCtx, + execute::{BlockAssembler, BlockAssemblerInput}, +}; +use reth_execution_errors::BlockExecutionError; +use reth_execution_types::BlockExecutionResult; +use reth_seismic_primitives::{SeismicReceipt, SeismicTransactionSigned}; + +/// Block builder for Seismic. +#[derive(Debug, Clone)] +pub struct SeismicBlockAssembler<ChainSpec> { + /// The chainspec. + pub chain_spec: Arc<ChainSpec>, + /// Extra data to use for the blocks. + pub extra_data: Bytes, +} + +impl<ChainSpec> SeismicBlockAssembler<ChainSpec> { + /// Creates a new [`SeismicBlockAssembler`]. + pub fn new(chain_spec: Arc<ChainSpec>) -> Self { + Self { chain_spec, extra_data: Default::default() } + } +} + +impl<F, ChainSpec> BlockAssembler<F> for SeismicBlockAssembler<ChainSpec> +where + F: for<'a> BlockExecutorFactory< + ExecutionCtx<'a> = EthBlockExecutionCtx<'a>, + Transaction = SeismicTransactionSigned, + Receipt = SeismicReceipt, + >, + ChainSpec: EthChainSpec + EthereumHardforks, +{ + type Block = Block<SeismicTransactionSigned>; + + fn assemble_block( + &self, + input: BlockAssemblerInput<'_, '_, F>, + ) -> Result<Block<SeismicTransactionSigned>, BlockExecutionError> { + let BlockAssemblerInput { + evm_env, + execution_ctx: ctx, + parent, + transactions, + output: BlockExecutionResult { receipts, requests, gas_used }, + state_root, + .. + } = input; + + // EVM block env timestamp is in milliseconds when feature is disabled, seconds when enabled + let timestamp = evm_env.block_env.timestamp.saturating_to(); + + // For fork activation checks, we always need seconds + let timestamp_seconds = + if cfg!(feature = "timestamp-in-seconds") { timestamp } else { timestamp / 1000 }; + + let transactions_root = proofs::calculate_transaction_root(&transactions); + let receipts_root = SeismicReceipt::calculate_receipt_root_no_memo(receipts); + let logs_bloom = logs_bloom(receipts.iter().flat_map(|r| r.logs())); + + let withdrawals = self + .chain_spec + .is_shanghai_active_at_timestamp(timestamp_seconds) + .then(|| ctx.withdrawals.map(|w| w.into_owned()).unwrap_or_default()); + + let withdrawals_root = + withdrawals.as_deref().map(|w| proofs::calculate_withdrawals_root(w)); + let requests_hash = self + .chain_spec + .is_prague_active_at_timestamp(timestamp_seconds) + .then(|| requests.requests_hash()); + + let mut excess_blob_gas = None; + let mut blob_gas_used = None; + + // only determine cancun fields when active + if self.chain_spec.is_cancun_active_at_timestamp(timestamp_seconds) { + blob_gas_used = + Some(transactions.iter().map(|tx| tx.blob_gas_used().unwrap_or_default()).sum()); + excess_blob_gas = + if self.chain_spec.is_cancun_active_at_timestamp(parent.timestamp_seconds()) { + parent.maybe_next_block_excess_blob_gas( + self.chain_spec.blob_params_at_timestamp(timestamp_seconds), + ) + } else { + // for the first post-fork block, both parent.blob_gas_used and + // parent.excess_blob_gas are evaluated as 0 + Some( + alloy_eips::eip7840::BlobParams::cancun() + .next_block_excess_blob_gas_osaka(0, 0, 0), + ) + }; + } + + let header = Header { + parent_hash: ctx.parent_hash, + ommers_hash: EMPTY_OMMER_ROOT_HASH, + beneficiary: evm_env.block_env.beneficiary, + state_root, + transactions_root, + receipts_root, + withdrawals_root, + logs_bloom, + timestamp, + mix_hash: evm_env.block_env.prevrandao.unwrap_or_default(), + nonce: BEACON_NONCE.into(), + base_fee_per_gas: Some(evm_env.block_env.basefee), + number: evm_env.block_env.number.saturating_to(), + gas_limit: evm_env.block_env.gas_limit, + difficulty: evm_env.block_env.difficulty, + gas_used: *gas_used, + extra_data: self.extra_data.clone(), + parent_beacon_block_root: ctx.parent_beacon_block_root, + blob_gas_used, + excess_blob_gas, + requests_hash, + }; + + Ok(Block { + header, + body: BlockBody { transactions, ommers: Default::default(), withdrawals }, + }) + } +}

diff --git reth/crates/seismic/evm/src/config.rs seismic-reth/crates/seismic/evm/src/config.rs new file mode 100644 index 0000000000000000000000000000000000000000..c04d5e171d6f98be76dbe7786705873ce54a1c2f --- /dev/null +++ seismic-reth/crates/seismic/evm/src/config.rs @@ -0,0 +1,22 @@ +//! Helpers for configuring the `SeismicSpecId` for the evm + +use crate::Header; +use alloy_consensus::BlockHeader; +use reth_chainspec::ChainSpec as SeismicChainSpec; +use seismic_revm::SeismicSpecId; + +/// Map the latest active hardfork at the given header to a revm [`SeismicSpecId`]. +pub fn revm_spec(chain_spec: &SeismicChainSpec, header: &Header) -> SeismicSpecId { + revm_spec_by_timestamp_seismic(chain_spec, header.timestamp()) +} + +/// Map the latest active hardfork at the given timestamp or block number to a revm +/// [`SeismicSpecId`]. +/// +/// For now our only hardfork is MERCURY, so we only return MERCURY +const fn revm_spec_by_timestamp_seismic( + _chain_spec: &SeismicChainSpec, + _timestamp: u64, +) -> SeismicSpecId { + SeismicSpecId::MERCURY +}

diff --git reth/crates/seismic/evm/src/lib.rs seismic-reth/crates/seismic/evm/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..7cc3d23dd76c1b56d121ecbfc3765eb1962aa546 --- /dev/null +++ seismic-reth/crates/seismic/evm/src/lib.rs @@ -0,0 +1,936 @@ +//! EVM config for vanilla seismic. + +#![doc( + html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png", + html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256", + issue_tracker_base_url = "https://github.com/SeismicSystems/seismic-reth/issues/" +)] +#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))] +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; + +use alloc::{borrow::Cow, sync::Arc}; +use alloy_consensus::{BlockHeader, Header}; +use alloy_eips::{eip1559::INITIAL_BASE_FEE, Decodable2718}; +use alloy_evm::{eth::EthBlockExecutionCtx, EvmFactory}; +use alloy_primitives::{Bytes, U256}; +use alloy_rpc_types_engine::ExecutionData; +pub use alloy_seismic_evm::{block::SeismicBlockExecutorFactory, SeismicEvm, SeismicEvmFactory}; +use build::SeismicBlockAssembler; +use core::fmt::Debug; +use reth_chainspec::{ChainSpec, EthChainSpec}; +use reth_ethereum_forks::EthereumHardfork; +use reth_evm::{ + ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, ExecutableTxIterator, ExecutionCtxFor, + NextBlockEnvAttributes, +}; +use reth_primitives_traits::{SealedBlock, SealedHeader, SignedTransaction, TxTy}; +use reth_seismic_primitives::{SeismicBlock, SeismicPrimitives}; +use reth_storage_errors::any::AnyError; +use revm::{ + context::{BlockEnv, CfgEnv}, + context_interface::block::BlobExcessGasAndPrice, +}; +use seismic_revm::SeismicSpecId; +use std::convert::Infallible; + +mod receipts; +pub use receipts::*; +mod build; + +pub mod config; +use config::revm_spec; + +/// Seismic EVM configuration. +#[derive(Debug, Clone)] +pub struct SeismicEvmConfig { + /// Inner [`SeismicBlockExecutorFactory`]. + pub executor_factory: + SeismicBlockExecutorFactory<SeismicRethReceiptBuilder, Arc<ChainSpec>, SeismicEvmFactory>, + /// Seismic block assembler. + pub block_assembler: SeismicBlockAssembler<ChainSpec>, +} + +impl SeismicEvmConfig { + /// Creates a new Seismic EVM configuration with the given chain spec and purpose keys. + pub fn new( + chain_spec: Arc<ChainSpec>, + purpose_keys: &'static seismic_enclave::GetPurposeKeysResponse, + ) -> Self { + Self::new_with_evm_factory( + chain_spec, + SeismicEvmFactory::new_with_purpose_keys(purpose_keys), + purpose_keys, + ) + } + + /// Creates a new Ethereum EVM configuration with the given chain spec and EVM factory. + pub fn new_with_evm_factory( + chain_spec: Arc<ChainSpec>, + evm_factory: SeismicEvmFactory, + purpose_keys: &'static seismic_enclave::GetPurposeKeysResponse, + ) -> Self { + Self { + block_assembler: SeismicBlockAssembler::new(chain_spec.clone()), + executor_factory: SeismicBlockExecutorFactory::new( + SeismicRethReceiptBuilder::default(), + chain_spec, + evm_factory, + purpose_keys, + ), + } + } + + /// Returns the chain spec associated with this configuration. + pub const fn chain_spec(&self) -> &Arc<ChainSpec> { + self.executor_factory.spec() + } + + /// Sets the extra data for the block assembler. + pub fn with_extra_data(mut self, extra_data: Bytes) -> Self { + self.block_assembler.extra_data = extra_data; + self + } + + /// Creates an EVM with the pre-fetched purpose keys + pub fn evm_with_env_and_live_key<DB>( + &self, + db: DB, + evm_env: EvmEnv<SeismicSpecId>, + ) -> SeismicEvm<DB, revm::inspector::NoOpInspector> + where + DB: alloy_evm::Database, + { + self.executor_factory.evm_factory().create_evm(db, evm_env) + } +} + +impl ConfigureEvm for SeismicEvmConfig { + type Primitives = SeismicPrimitives; + type Error = Infallible; + type NextBlockEnvCtx = NextBlockEnvAttributes; + type BlockExecutorFactory = + SeismicBlockExecutorFactory<SeismicRethReceiptBuilder, Arc<ChainSpec>, SeismicEvmFactory>; + type BlockAssembler = SeismicBlockAssembler<ChainSpec>; + + fn block_executor_factory(&self) -> &Self::BlockExecutorFactory { + &self.executor_factory + } + + fn block_assembler(&self) -> &Self::BlockAssembler { + &self.block_assembler + } + + fn evm_env(&self, header: &Header) -> EvmEnv<SeismicSpecId> { + // TODO: use the correct spec id + let spec = SeismicSpecId::MERCURY; + + // configure evm env based on parent block + let cfg_env = CfgEnv::new().with_chain_id(self.chain_spec().chain().id()).with_spec(spec); + + let block_env = BlockEnv { + number: U256::from(header.number()), + beneficiary: header.beneficiary(), + timestamp: U256::from(header.timestamp()), + difficulty: U256::ZERO, + prevrandao: header.mix_hash(), /* Seismic genesis spec (Mercury) starts after Paris, + * so we always use header.mix_hash() */ + gas_limit: header.gas_limit(), + basefee: header.base_fee_per_gas().unwrap_or_default(), + // EIP-4844 excess blob gas of this block, introduced in Cancun + blob_excess_gas_and_price: header.excess_blob_gas.map(|excess_blob_gas| { + BlobExcessGasAndPrice::new_with_spec(excess_blob_gas, spec.into_eth_spec()) + }), + }; + + EvmEnv { cfg_env, block_env } + } + + fn next_evm_env( + &self, + parent: &Header, + attributes: &NextBlockEnvAttributes, + ) -> Result<EvmEnv<SeismicSpecId>, Self::Error> { + let spec_id = revm_spec(self.chain_spec(), parent); + + // configure evm env based on parent block + let cfg = CfgEnv::new().with_chain_id(self.chain_spec().chain().id()).with_spec(spec_id); + + // if the parent block did not have excess blob gas (i.e. it was pre-cancun), but it is + // cancun now, we need to set the excess blob gas to the default value(0) + let blob_excess_gas_and_price = parent + .maybe_next_block_excess_blob_gas( + self.chain_spec().blob_params_at_timestamp(attributes.timestamp_seconds()), + ) + .map(|gas| BlobExcessGasAndPrice::new_with_spec(gas, spec_id.into_eth_spec())); + + let mut basefee = parent.next_block_base_fee( + self.chain_spec().base_fee_params_at_timestamp(attributes.timestamp_seconds()), + ); + + let mut gas_limit = attributes.gas_limit; + + // If we are on the London fork boundary, we need to multiply the parent's gas limit by the + // elasticity multiplier to get the new gas limit. + if self.chain_spec().fork(EthereumHardfork::London).transitions_at_block(parent.number + 1) + { + let elasticity_multiplier = self + .chain_spec() + .base_fee_params_at_timestamp(attributes.timestamp_seconds()) + .elasticity_multiplier; + + // multiply the gas limit by the elasticity multiplier + gas_limit *= elasticity_multiplier as u64; + + // set the base fee to the initial base fee from the EIP-1559 spec + basefee = Some(INITIAL_BASE_FEE) + } + + let block_env = BlockEnv { + number: U256::from(parent.number + 1), + beneficiary: attributes.suggested_fee_recipient, + // When timestamp-in-seconds is disabled, EVM should use milliseconds + timestamp: U256::from(attributes.timestamp), + difficulty: U256::ZERO, + prevrandao: Some(attributes.prev_randao), + gas_limit, + // calculate basefee based on parent block's gas usage + basefee: basefee.unwrap_or_default(), + // calculate excess gas based on parent block's blob gas usage + blob_excess_gas_and_price, + }; + + Ok((cfg, block_env).into()) + } + + fn context_for_block<'a>( + &self, + block: &'a SealedBlock<SeismicBlock>, + ) -> EthBlockExecutionCtx<'a> { + EthBlockExecutionCtx { + parent_hash: block.header().parent_hash, + parent_beacon_block_root: block.header().parent_beacon_block_root, + ommers: &block.body().ommers, + withdrawals: block.body().withdrawals.as_ref().map(Cow::Borrowed), + } + } + + fn context_for_next_block( + &self, + parent: &SealedHeader, + attributes: Self::NextBlockEnvCtx, + ) -> EthBlockExecutionCtx<'_> { + EthBlockExecutionCtx { + parent_hash: parent.hash(), + parent_beacon_block_root: attributes.parent_beacon_block_root, + ommers: &[], + withdrawals: attributes.withdrawals.map(Cow::Owned), + } + } + + /// Override to use pre-fetched live RNG key + fn evm_with_env<DB: alloy_evm::Database>( + &self, + db: DB, + evm_env: EvmEnv<SeismicSpecId>, + ) -> SeismicEvm<DB, revm::inspector::NoOpInspector> { + self.evm_with_env_and_live_key(db, evm_env) + } +} + +impl ConfigureEngineEvm<ExecutionData> for SeismicEvmConfig { + fn evm_env_for_payload(&self, payload: &ExecutionData) -> EvmEnvFor<Self> { + // Create a temporary header with the payload information to determine the spec + let temp_header = Header { + number: payload.payload.block_number(), + timestamp: payload.payload.timestamp(), + gas_limit: payload.payload.gas_limit(), + beneficiary: payload.payload.fee_recipient(), + ..Default::default() + }; + let spec_id = revm_spec(self.chain_spec(), &temp_header); + + let cfg_env = + CfgEnv::new().with_chain_id(self.chain_spec().chain().id()).with_spec(spec_id); + + let blob_excess_gas_and_price = payload + .payload + .blob_gas_used() + .map(|_gas| BlobExcessGasAndPrice::new_with_spec(0, spec_id.into_eth_spec())); + + let block_env = BlockEnv { + number: U256::from(payload.payload.block_number()), + beneficiary: payload.payload.fee_recipient(), + timestamp: U256::from(payload.payload.timestamp()), + difficulty: U256::ZERO, + prevrandao: Some(payload.payload.prev_randao()), + gas_limit: payload.payload.gas_limit(), + basefee: payload.payload.saturated_base_fee_per_gas(), + blob_excess_gas_and_price, + }; + + (cfg_env, block_env).into() + } + + fn context_for_payload<'a>(&self, payload: &'a ExecutionData) -> ExecutionCtxFor<'a, Self> { + EthBlockExecutionCtx { + parent_hash: payload.payload.parent_hash(), + parent_beacon_block_root: payload.sidecar.parent_beacon_block_root(), + ommers: &[], + withdrawals: payload.payload.withdrawals().map(|w| Cow::Owned(w.clone().into())), + } + } + + fn tx_iterator_for_payload(&self, payload: &ExecutionData) -> impl ExecutableTxIterator<Self> { + payload.payload.transactions().clone().into_iter().map(|tx| { + let mut tx_data = tx.as_ref(); + let tx = TxTy::<Self::Primitives>::decode_2718(&mut tx_data).map_err(AnyError::new)?; + let signer = tx.try_recover().map_err(AnyError::new)?; + Ok::<_, AnyError>(tx.with_signer(signer)) + }) + } +} + +#[cfg(test)] +#[allow(clippy::expect_used)] // Test code - expect on failure is acceptable +#[allow(clippy::unwrap_used)] // Test code - unwrap on failure is acceptable +#[allow(clippy::panic)] // Test code - panic on failure is acceptable +mod tests { + use super::*; + use alloy_consensus::{Header, Receipt}; + use alloy_eips::eip7685::Requests; + use alloy_evm::Evm; + use alloy_genesis::Genesis; + use alloy_primitives::{bytes, map::HashMap, Address, LogData, B256}; + use reth_chainspec::ChainSpec; + use reth_evm::execute::ProviderError; + use reth_execution_types::{ + AccountRevertInit, BundleStateInit, Chain, ExecutionOutcome, RevertsInit, + }; + use reth_primitives_traits::{Account, RecoveredBlock}; + use reth_seismic_chainspec::SEISMIC_MAINNET; + use reth_seismic_primitives::{SeismicBlock, SeismicPrimitives, SeismicReceipt}; + use revm::{ + database::{BundleState, CacheDB}, + database_interface::EmptyDBTyped, + handler::PrecompileProvider, + inspector::NoOpInspector, + precompile::u64_to_address, + primitives::Log, + state::AccountInfo, + }; + use seismic_enclave::{ + get_unsecure_sample_schnorrkel_keypair, get_unsecure_sample_secp256k1_pk, + get_unsecure_sample_secp256k1_sk, GetPurposeKeysResponse, + }; + use std::sync::Arc; + + fn test_evm_config() -> SeismicEvmConfig { + // Get mock purpose keys for testing + let mock_keys = Box::leak(Box::new(get_mock_keys())); + + SeismicEvmConfig::new(SEISMIC_MAINNET.clone(), mock_keys) + } + + fn get_mock_keys() -> GetPurposeKeysResponse { + GetPurposeKeysResponse { + tx_io_sk: get_unsecure_sample_secp256k1_sk(), + tx_io_pk: get_unsecure_sample_secp256k1_pk(), + snapshot_key_bytes: [0u8; 32], + rng_keypair: get_unsecure_sample_schnorrkel_keypair(), + } + } + + #[test] + fn test_fill_cfg_and_block_env() { + // Create a default header + let header = Header::default(); + + // Build the ChainSpec for Ethereum mainnet, activating London, Paris, and Shanghai + // hardforks + let chain_spec = ChainSpec::builder() + .chain(0.into()) + .genesis(Genesis::default()) + .london_activated() + .paris_activated() + .shanghai_activated() + .build(); + + // Use the `SeismicEvmConfig` to create the `cfg_env` and `block_env` based on the + // ChainSpec, Header, and total difficulty + let mock_keys = Box::leak(Box::new(get_mock_keys())); + let EvmEnv { cfg_env, .. } = + SeismicEvmConfig::new(Arc::new(chain_spec.clone()), mock_keys).evm_env(&header); + + // Assert that the chain ID in the `cfg_env` is correctly set to the chain ID of the + // ChainSpec + assert_eq!(cfg_env.chain_id, chain_spec.chain().id()); + } + + #[test] + fn test_seismic_evm_with_env_default_spec() { + // Setup the EVM with test config and environment + let evm_config = test_evm_config(); // Provides SeismicEvm config with Seismic mainnet spec + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + let evm_env = EvmEnv::default(); + let evm: SeismicEvm<_, NoOpInspector> = evm_config.evm_with_env(db, evm_env.clone()); + let precompiles = evm.precompiles().clone(); + + // Check that the EVM environment is correctly set + assert_eq!(evm.cfg, evm_env.cfg_env); + assert_eq!(evm.cfg.spec, SeismicSpecId::MERCURY); + + // Check that the expected number of precompiles is set + let precompile_addresses = + [u64_to_address(101), u64_to_address(102), u64_to_address(103), u64_to_address(104)]; + for &addr in &precompile_addresses { + let is_contained = precompiles.contains(&addr); + assert!( + is_contained, + "Expected Precompile at address for RETH evm generation {addr:?}" + ); + } + } + + #[test] + fn test_evm_with_env_custom_cfg() { + let evm_config = test_evm_config(); + + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + // Create a custom configuration environment with a chain ID of 111 + let cfg = CfgEnv::new().with_chain_id(111).with_spec(SeismicSpecId::default()); + + let evm_env = EvmEnv { cfg_env: cfg.clone(), ..Default::default() }; + + let evm = evm_config.evm_with_env(db, evm_env); + + // Check that the EVM environment is initialized with the custom environment + assert_eq!(evm.cfg, cfg); + } + + #[test] + fn test_evm_with_env_custom_block_and_tx() { + let evm_config = test_evm_config(); + + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + // Create customs block and tx env + let block = BlockEnv { + basefee: 1000, + gas_limit: 10_000_000, + number: U256::from(42), + ..Default::default() + }; + + let evm_env = EvmEnv { block_env: block, ..Default::default() }; + + let evm = evm_config.evm_with_env(db, evm_env.clone()); + + // Verify that the block and transaction environments are set correctly + assert_eq!(evm.block, evm_env.block_env); + } + + #[test] + fn test_evm_with_spec_id() { + let evm_config = test_evm_config(); + + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + let evm_env = EvmEnv { + cfg_env: CfgEnv::new().with_spec(SeismicSpecId::MERCURY), + ..Default::default() + }; + + let evm = evm_config.evm_with_env(db, evm_env.clone()); + + assert_eq!(evm.cfg, evm_env.cfg_env); + } + + #[test] + fn test_evm_with_env_and_default_inspector() { + let evm_config = test_evm_config(); + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + let evm_env = EvmEnv { cfg_env: Default::default(), ..Default::default() }; + + let evm = evm_config.evm_with_env_and_inspector(db, evm_env.clone(), NoOpInspector {}); + + // Check that the EVM environment is set to default values + assert_eq!(*evm.block(), evm_env.block_env); + assert_eq!(evm.cfg, evm_env.cfg_env); + } + + #[test] + fn test_evm_with_env_inspector_and_custom_cfg() { + let evm_config = test_evm_config(); + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + let cfg = CfgEnv::new().with_chain_id(111).with_spec(SeismicSpecId::MERCURY); + let block = BlockEnv::default(); + let evm_env = EvmEnv { block_env: block, cfg_env: cfg.clone() }; + + let evm = evm_config.evm_with_env_and_inspector(db, evm_env.clone(), NoOpInspector {}); + + // Check that the EVM environment is set with custom configuration + assert_eq!(evm.cfg, cfg); + assert_eq!(evm.block, evm_env.block_env); + } + + #[test] + fn test_evm_with_env_inspector_and_custom_block_tx() { + let evm_config = test_evm_config(); + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + // Create custom block and tx environment + let block = BlockEnv { + basefee: 1000, + gas_limit: 10_000_000, + number: U256::from(42), + ..Default::default() + }; + let evm_env = EvmEnv { block_env: block, ..Default::default() }; + + let evm = evm_config.evm_with_env_and_inspector(db, evm_env.clone(), NoOpInspector {}); + + // Verify that the block and transaction environments are set correctly + assert_eq!(evm.block, evm_env.block_env); + } + + #[test] + fn test_evm_with_env_inspector_and_spec_id() { + let evm_config = test_evm_config(); + let db = CacheDB::<EmptyDBTyped<ProviderError>>::default(); + + let evm_env = EvmEnv { + cfg_env: CfgEnv::new().with_spec(SeismicSpecId::MERCURY), + ..Default::default() + }; + + let evm = evm_config.evm_with_env_and_inspector(db, evm_env.clone(), NoOpInspector {}); + + // Check that the spec ID is set properly + assert_eq!(evm.cfg, evm_env.cfg_env); + assert_eq!(evm.block, evm_env.block_env); + } + + #[test] + fn receipts_by_block_hash() { + // Create a default recovered block + let block: RecoveredBlock<SeismicBlock> = Default::default(); + + // Define block hashes for block1 and block2 + let block1_hash = B256::new([0x01; 32]); + let block2_hash = B256::new([0x02; 32]); + + // Clone the default block into block1 and block2 + let mut block1 = block.clone(); + let mut block2 = block; + + // Set the hashes of block1 and block2 + block1.set_block_number(10); + block1.set_hash(block1_hash); + + block2.set_block_number(11); + block2.set_hash(block2_hash); + + // Create a random receipt object, receipt1 + let receipt1 = SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }); + + // Create another random receipt object, receipt2 + let receipt2 = SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 1325345, + logs: vec![], + status: true.into(), + }); + + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![receipt1.clone()], vec![receipt2]]; + + // Create an ExecutionOutcome object with the created bundle, receipts, an empty requests + // vector, and first_block set to 10 + let execution_outcome = ExecutionOutcome::<SeismicReceipt> { + bundle: Default::default(), + receipts, + requests: vec![], + first_block: 10, + }; + + // Create a Chain object with a BTreeMap of blocks mapped to their block numbers, + // including block1_hash and block2_hash, and the execution_outcome + let chain: Chain<SeismicPrimitives> = + Chain::new([block1, block2], execution_outcome.clone(), None); + + // Assert that the proper receipt vector is returned for block1_hash + assert_eq!(chain.receipts_by_block_hash(block1_hash), Some(vec![&receipt1])); + + // Create an ExecutionOutcome object with a single receipt vector containing receipt1 + let execution_outcome1 = ExecutionOutcome { + bundle: Default::default(), + receipts: vec![vec![receipt1]], + requests: vec![], + first_block: 10, + }; + + // Assert that the execution outcome at the first block contains only the first receipt + assert_eq!(chain.execution_outcome_at_block(10), Some(execution_outcome1)); + + // Assert that the execution outcome at the tip block contains the whole execution outcome + assert_eq!(chain.execution_outcome_at_block(11), Some(execution_outcome)); + } + + #[test] + fn test_initialisation() { + // Create a new BundleState object with initial data + let bundle = BundleState::new( + vec![(Address::new([2; 20]), None, Some(AccountInfo::default()), HashMap::default())], + vec![vec![(Address::new([2; 20]), None, vec![])]], + vec![], + ); + + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![Some(SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }))]]; + + // Create a Requests object with a vector of requests + let requests = vec![Requests::new(vec![bytes!("dead"), bytes!("beef"), bytes!("beebee")])]; + + // Define the first block number + let first_block = 123; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = ExecutionOutcome { + bundle: bundle.clone(), + receipts: receipts.clone(), + requests: requests.clone(), + first_block, + }; + + // Assert that creating a new ExecutionOutcome using the constructor matches exec_res + assert_eq!( + ExecutionOutcome::new(bundle, receipts.clone(), first_block, requests.clone()), + exec_res + ); + + // Create a BundleStateInit object and insert initial data + let mut state_init: BundleStateInit = HashMap::default(); + state_init + .insert(Address::new([2; 20]), (None, Some(Account::default()), HashMap::default())); + + // Create a HashMap for account reverts and insert initial data + let mut revert_inner: HashMap<Address, AccountRevertInit> = HashMap::default(); + revert_inner.insert(Address::new([2; 20]), (None, vec![])); + + // Create a RevertsInit object and insert the revert_inner data + let mut revert_init: RevertsInit = HashMap::default(); + revert_init.insert(123, revert_inner); + + // Assert that creating a new ExecutionOutcome using the new_init method matches + // exec_res + assert_eq!( + ExecutionOutcome::new_init( + state_init, + revert_init, + vec![], + receipts, + first_block, + requests, + ), + exec_res + ); + } + + #[test] + fn test_block_number_to_index() { + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![Some(SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }))]]; + + // Define the first block number + let first_block = 123; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = ExecutionOutcome { + bundle: Default::default(), + receipts, + requests: vec![], + first_block, + }; + + // Test before the first block + assert_eq!(exec_res.block_number_to_index(12), None); + + // Test after after the first block but index larger than receipts length + assert_eq!(exec_res.block_number_to_index(133), None); + + // Test after the first block + assert_eq!(exec_res.block_number_to_index(123), Some(0)); + } + + #[test] + fn test_get_logs() { + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![Log::<LogData>::default()], + status: true.into(), + })]]; + + // Define the first block number + let first_block = 123; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = ExecutionOutcome { + bundle: Default::default(), + receipts, + requests: vec![], + first_block, + }; + + // Get logs for block number 123 + let logs: Vec<&Log> = exec_res.logs(123).unwrap().collect(); + + // Assert that the logs match the expected logs + assert_eq!(logs, vec![&Log::<LogData>::default()]); + } + + #[test] + fn test_receipts_by_block() { + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![Some(SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![Log::<LogData>::default()], + status: true.into(), + }))]]; + + // Define the first block number + let first_block = 123; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = ExecutionOutcome { + bundle: Default::default(), // Default value for bundle + receipts, // Include the created receipts + requests: vec![], // Empty vector for requests + first_block, // Set the first block number + }; + + // Get receipts for block number 123 and convert the result into a vector + let receipts_by_block: Vec<_> = exec_res.receipts_by_block(123).iter().collect(); + + // Assert that the receipts for block number 123 match the expected receipts + assert_eq!( + receipts_by_block, + vec![&Some(SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![Log::<LogData>::default()], + status: true.into(), + }))] + ); + } + + #[test] + fn test_receipts_len() { + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![Some(SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![Log::<LogData>::default()], + status: true.into(), + }))]]; + + // Create an empty Receipts object + let receipts_empty = vec![]; + + // Define the first block number + let first_block = 123; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = ExecutionOutcome { + bundle: Default::default(), // Default value for bundle + receipts, // Include the created receipts + requests: vec![], // Empty vector for requests + first_block, // Set the first block number + }; + + // Assert that the length of receipts in exec_res is 1 + assert_eq!(exec_res.len(), 1); + + // Assert that exec_res is not empty + assert!(!exec_res.is_empty()); + + // Create a ExecutionOutcome object with an empty Receipts object + let exec_res_empty_receipts: ExecutionOutcome<SeismicReceipt> = ExecutionOutcome { + bundle: Default::default(), // Default value for bundle + receipts: receipts_empty, // Include the empty receipts + requests: vec![], // Empty vector for requests + first_block, // Set the first block number + }; + + // Assert that the length of receipts in exec_res_empty_receipts is 0 + assert_eq!(exec_res_empty_receipts.len(), 0); + + // Assert that exec_res_empty_receipts is empty + assert!(exec_res_empty_receipts.is_empty()); + } + + #[test] + fn test_revert_to() { + // Create a random receipt object + let receipt = SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }); + + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![vec![Some(receipt.clone())], vec![Some(receipt.clone())]]; + + // Define the first block number + let first_block = 123; + + // Create a request. + let request = bytes!("deadbeef"); + + // Create a vector of Requests containing the request. + let requests = + vec![Requests::new(vec![request.clone()]), Requests::new(vec![request.clone()])]; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let mut exec_res = + ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block }; + + // Assert that the revert_to method returns true when reverting to the initial block number. + assert!(exec_res.revert_to(123)); + + // Assert that the receipts are properly cut after reverting to the initial block number. + assert_eq!(exec_res.receipts, vec![vec![Some(receipt)]]); + + // Assert that the requests are properly cut after reverting to the initial block number. + assert_eq!(exec_res.requests, vec![Requests::new(vec![request])]); + + // Assert that the revert_to method returns false when attempting to revert to a block + // number greater than the initial block number. + assert!(!exec_res.revert_to(133)); + + // Assert that the revert_to method returns false when attempting to revert to a block + // number less than the initial block number. + assert!(!exec_res.revert_to(10)); + } + + #[test] + fn test_extend_execution_outcome() { + // Create a Receipt object with specific attributes. + let receipt = SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }); + + // Create a Receipts object containing the receipt. + let receipts = vec![vec![Some(receipt.clone())]]; + + // Create a request. + let request = bytes!("deadbeef"); + + // Create a vector of Requests containing the request. + let requests = vec![Requests::new(vec![request.clone()])]; + + // Define the initial block number. + let first_block = 123; + + // Create an ExecutionOutcome object. + let mut exec_res = + ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block }; + + // Extend the ExecutionOutcome object by itself. + exec_res.extend(exec_res.clone()); + + // Assert the extended ExecutionOutcome matches the expected outcome. + assert_eq!( + exec_res, + ExecutionOutcome { + bundle: Default::default(), + receipts: vec![vec![Some(receipt.clone())], vec![Some(receipt)]], + requests: vec![Requests::new(vec![request.clone()]), Requests::new(vec![request])], + first_block: 123, + } + ); + } + + #[test] + fn test_split_at_execution_outcome() { + // Create a random receipt object + let receipt = SeismicReceipt::Legacy(Receipt { + cumulative_gas_used: 46913, + logs: vec![], + status: true.into(), + }); + + // Create a Receipts object with a vector of receipt vectors + let receipts = vec![ + vec![Some(receipt.clone())], + vec![Some(receipt.clone())], + vec![Some(receipt.clone())], + ]; + + // Define the first block number + let first_block = 123; + + // Create a request. + let request = bytes!("deadbeef"); + + // Create a vector of Requests containing the request. + let requests = vec![ + Requests::new(vec![request.clone()]), + Requests::new(vec![request.clone()]), + Requests::new(vec![request.clone()]), + ]; + + // Create a ExecutionOutcome object with the created bundle, receipts, requests, and + // first_block + let exec_res = + ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block }; + + // Split the ExecutionOutcome at block number 124 + let result = exec_res.clone().split_at(124); + + // Define the expected lower ExecutionOutcome after splitting + let lower_execution_outcome = ExecutionOutcome { + bundle: Default::default(), + receipts: vec![vec![Some(receipt.clone())]], + requests: vec![Requests::new(vec![request.clone()])], + first_block, + }; + + // Define the expected higher ExecutionOutcome after splitting + let higher_execution_outcome = ExecutionOutcome { + bundle: Default::default(), + receipts: vec![vec![Some(receipt.clone())], vec![Some(receipt)]], + requests: vec![Requests::new(vec![request.clone()]), Requests::new(vec![request])], + first_block: 124, + }; + + // Assert that the split result matches the expected lower and higher outcomes + assert_eq!(result.0, Some(lower_execution_outcome)); + assert_eq!(result.1, higher_execution_outcome); + + // Assert that splitting at the first block number returns None for the lower outcome + assert_eq!(exec_res.clone().split_at(123), (None, exec_res)); + } +}

diff --git reth/crates/seismic/evm/src/receipts.rs seismic-reth/crates/seismic/evm/src/receipts.rs new file mode 100644 index 0000000000000000000000000000000000000000..92f0ccbe5354f63dbb9aa088a6cd1f91a353f7a6 --- /dev/null +++ seismic-reth/crates/seismic/evm/src/receipts.rs @@ -0,0 +1,39 @@ +use alloy_consensus::{Eip658Value, Receipt}; +use alloy_evm::eth::receipt_builder::{ReceiptBuilder, ReceiptBuilderCtx}; +use reth_evm::Evm; +use reth_seismic_primitives::{SeismicReceipt, SeismicTransactionSigned}; +use seismic_alloy_consensus::SeismicTxType; + +/// A builder that operates on seismic-reth primitive types, specifically +/// [`SeismicTransactionSigned`] and [`SeismicReceipt`]. +/// +/// Why is this different than `SeismicAlloyReceiptBuilder` in seismic-evm? Can we reuse code? +#[derive(Debug, Default, Clone, Copy)] +#[non_exhaustive] +pub struct SeismicRethReceiptBuilder; + +impl ReceiptBuilder for SeismicRethReceiptBuilder { + type Transaction = SeismicTransactionSigned; + type Receipt = SeismicReceipt; + + fn build_receipt<E: Evm>( + &self, + ctx: ReceiptBuilderCtx<'_, SeismicTransactionSigned, E>, + ) -> Self::Receipt { + let ty = ctx.tx.tx_type(); + let receipt = Receipt { + status: Eip658Value::Eip658(ctx.result.is_success()), + cumulative_gas_used: ctx.cumulative_gas_used, + logs: ctx.result.into_logs(), + }; + + match ty { + SeismicTxType::Legacy => SeismicReceipt::Legacy(receipt), + SeismicTxType::Eip1559 => SeismicReceipt::Eip1559(receipt), + SeismicTxType::Eip2930 => SeismicReceipt::Eip2930(receipt), + SeismicTxType::Eip4844 => SeismicReceipt::Eip4844(receipt), + SeismicTxType::Eip7702 => SeismicReceipt::Eip7702(receipt), + SeismicTxType::Seismic => SeismicReceipt::Seismic(receipt), + } + } +}

diff --git reth/crates/seismic/node/Cargo.toml seismic-reth/crates/seismic/node/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..6d5e4be027042dec4332e83079d925e71f53a8e5 --- /dev/null +++ seismic-reth/crates/seismic/node/Cargo.toml @@ -0,0 +1,166 @@ +[package] +name = "reth-seismic-node" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +seismic-enclave.workspace = true + +# seismic-reth +reth-seismic-payload-builder.workspace = true +reth-seismic-evm.workspace = true +reth-seismic-rpc.workspace = true +reth-seismic-txpool.workspace = true +reth-seismic-chainspec = { workspace = true, optional = true } +reth-seismic-primitives = { workspace = true, features = ["serde", "serde-bincode-compat", "reth-codec"] } + +# reth +reth-chainspec.workspace = true +reth-primitives-traits.workspace = true +reth-payload-builder.workspace = true +# reth-codecs.workspace = true +reth-consensus.workspace = true +reth-node-api.workspace = true +reth-node-core.workspace = true +reth-node-builder.workspace = true +reth-provider.workspace = true +reth-transaction-pool.workspace = true +reth-network.workspace = true +reth-evm.workspace = true +reth-rpc-server-types.workspace = true +reth-rpc-eth-api.workspace = true +reth-rpc-eth-types.workspace = true +reth-rpc-api.workspace = true +reth-node-ethereum.workspace = true +reth-payload-primitives.workspace = true +reth-engine-primitives.workspace = true +reth-engine-local.workspace = true +reth-eth-wire-types.workspace = true +reth-rpc.workspace = true +reth-rpc-builder.workspace = true +reth-ethereum-payload-builder.workspace = true + +# revm +revm = { workspace = true, features = ["secp256k1", "blst", "c-kzg"] } + +# alloy +alloy-consensus.workspace = true +alloy-eips.workspace = true +alloy-primitives.workspace = true +alloy-rpc-types-engine.workspace = true +alloy-rpc-types-eth.workspace = true + +seismic-alloy-consensus.workspace = true +seismic-alloy-rpc-types.workspace = true +seismic-revm = { workspace = true } + +# misc +serde.workspace = true +eyre.workspace = true +tracing.workspace = true + +# rpc +jsonrpsee-http-client.workspace = true + +# test-utils dependencies +alloy-rpc-types = { workspace = true } +tokio = { workspace = true } +jsonrpsee = { workspace = true } +reth-e2e-test-utils = { workspace = true, optional = true } +reth-tasks = { workspace = true, optional = true } +seismic-alloy-genesis = { workspace = true, optional = true } + +[dev-dependencies] +reth-seismic-node = { workspace = true, features = ["test-utils"] } +serde_json.workspace = true +reth-db.workspace = true +reth-node-core.workspace = true +reth-node-builder = { workspace = true, features = ["test-utils"] } +reth-provider = { workspace = true, features = ["test-utils"] } +reth-revm = { workspace = true, features = ["test-utils"] } +reth-tasks.workspace = true +reth-tracing.workspace = true +reth-trie-db.workspace = true +alloy-primitives.workspace = true +seismic-alloy-consensus.workspace = true +alloy-consensus.workspace = true +futures.workspace = true +reth-e2e-test-utils = { workspace = true } +reth-rpc-e2e-tests.workspace = true +reth-seismic-evm.workspace = true +reth-seismic-chainspec.workspace = true +alloy-network = { workspace = true } +alloy-chains.workspace = true +alloy-signer-local = { workspace = true } +alloy-genesis = { workspace = true } +reth-seismic-forks.workspace = true +seismic-alloy-network = { workspace = true } +seismic-alloy-provider = { workspace = true } +alloy-dyn-abi.workspace = true +alloy-sol-types.workspace = true +alloy-json-abi.workspace = true +alloy-provider.workspace = true +seismic-alloy-rpc-types.workspace = true +reth-exex.workspace = true +reqwest.workspace = true +secp256k1.workspace = true +k256.workspace = true +rand.workspace = true +alloy-signer.workspace = true +alloy-eips.workspace = true +reth-chainspec.workspace = true +reth-rpc-layer.workspace = true +reth-rpc-builder.workspace = true +reth-payload-builder.workspace = true +reth-primitives-traits.workspace = true +alloy-rpc-types-engine.workspace = true + +[features] +default = ["reth-codec"] +timestamp-in-seconds = [ + "seismic-revm/timestamp-in-seconds", + "reth-node-builder/timestamp-in-seconds", + "reth-primitives-traits/timestamp-in-seconds", + "reth-seismic-evm/timestamp-in-seconds", + "reth-seismic-payload-builder/timestamp-in-seconds", + "reth-seismic-primitives/timestamp-in-seconds", + "reth-seismic-rpc/timestamp-in-seconds", + "reth-seismic-chainspec/timestamp-in-seconds", +] +asm-keccak = [ + "alloy-primitives/asm-keccak", + "revm/asm-keccak", + "reth-seismic-node/asm-keccak", + "reth-node-core/asm-keccak", +] +js-tracer = [ + "reth-node-builder/js-tracer", +] +test-utils = [ + "reth-tasks", + "reth-e2e-test-utils", + "reth-seismic-chainspec", + "reth-node-builder/test-utils", + "reth-chainspec/test-utils", + "reth-consensus/test-utils", + "reth-evm/test-utils", + "reth-network/test-utils", + "reth-payload-builder/test-utils", + "reth-revm/test-utils", + "reth-provider/test-utils", + "reth-transaction-pool/test-utils", + "reth-trie-db/test-utils", + "reth-seismic-node/test-utils", + "reth-seismic-primitives/arbitrary", + "reth-primitives-traits/test-utils", +] +reth-codec = [ + "reth-seismic-primitives/reth-codec", +]

diff --git reth/crates/seismic/node/src/enclave.rs seismic-reth/crates/seismic/node/src/enclave.rs new file mode 100644 index 0000000000000000000000000000000000000000..83374ac093179d86c037e21280a1d616714f9ac8 --- /dev/null +++ seismic-reth/crates/seismic/node/src/enclave.rs @@ -0,0 +1,56 @@ +//! Tools to communicate with the seismic-enclave-server's RPC +use std::net::SocketAddr; + +use jsonrpsee_http_client::HttpClientBuilder; +use reth_node_core::args::EnclaveArgs; +use seismic_enclave::{ + api::TdxQuoteRpcClient as _, mock::start_mock_server, GetPurposeKeysResponse, +}; +use tracing::{info, warn}; + +/// Boot the enclave (or mock server) and fetch purpose keys. +/// This must be called before building the node components. +/// Panics if the enclave cannot be booted or purpose keys cannot be fetched. +#[allow(clippy::expect_used)] // Intentional panic on startup failure - enclave is required +#[allow(clippy::panic)] // Intentional panic on fetching keys failure - enclave keys are required +pub async fn boot_enclave_and_fetch_keys<T>(config: &T) -> GetPurposeKeysResponse +where + T: AsRef<EnclaveArgs>, +{ + let config = config.as_ref(); + // Boot enclave or start mock server + if config.mock_server { + info!(target: "reth::cli", "Starting mock enclave server"); + let addr = config.enclave_server_addr; + let port = config.enclave_server_port; + tokio::spawn(async move { + start_mock_server(SocketAddr::new(addr, port)) + .await + .expect("Failed to start mock enclave server"); + }); + // Give the mock server time to start + tokio::time::sleep(tokio::time::Duration::from_millis(100)).await; + } + let enclave_client = HttpClientBuilder::default() + .build(format!("http://{}:{}", config.enclave_server_addr, config.enclave_server_port)) + .expect("Failed to build enclave client"); + + // Fetch purpose keys from enclave - this must succeed or we panic + info!(target: "reth::cli", "Fetching purpose keys from enclave"); + let mut failures = 0; + while failures <= config.retries { + match enclave_client.get_purpose_keys(0).await { + Ok(purpose_keys) => { + info!(target: "reth::cli", "Successfully fetched purpose keys from enclave"); + return purpose_keys; + } + Err(e) => { + warn!(target: "reth::cli", "Failure to fetch purpose keys {}/{}: {}", failures, config.retries, e); + tokio::time::sleep(tokio::time::Duration::from_secs(config.retry_seconds.into())) + .await; + failures += 1; + } + } + } + panic!("FATAL: Failed to fetch purpose keys from enclave on boot after {} failures", failures); +}

diff --git reth/crates/seismic/node/src/engine.rs seismic-reth/crates/seismic/node/src/engine.rs new file mode 100644 index 0000000000000000000000000000000000000000..d1a5664a68e39109ef86ebc051b9f3e453b1a69b --- /dev/null +++ seismic-reth/crates/seismic/node/src/engine.rs @@ -0,0 +1,152 @@ +//! Ethereum specific engine API types and impls. + +use std::sync::Arc; + +use alloy_rpc_types_engine::{ExecutionData, ExecutionPayload, ExecutionPayloadEnvelopeV5}; +pub use alloy_rpc_types_engine::{ + ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3, ExecutionPayloadEnvelopeV4, + ExecutionPayloadV1, PayloadAttributes, +}; +use reth_chainspec::ChainSpec; +use reth_engine_primitives::{EngineTypes, PayloadValidator}; +use reth_ethereum_payload_builder::EthereumExecutionPayloadValidator; +use reth_node_api::{ + validate_execution_requests, validate_version_specific_fields, EngineApiMessageVersion, + EngineApiValidator, EngineObjectValidationError, NewPayloadError, PayloadOrAttributes, +}; +use reth_payload_builder::{EthBuiltPayload, EthPayloadBuilderAttributes}; +use reth_payload_primitives::{BuiltPayload, PayloadTypes}; +use reth_primitives_traits::{NodePrimitives, RecoveredBlock, SealedBlock}; +use reth_seismic_primitives::SeismicPrimitives; + +/// The types used in the default mainnet ethereum beacon consensus engine. +#[derive(Debug, Default, Clone, serde::Deserialize, serde::Serialize)] +#[non_exhaustive] +pub struct SeismicEngineTypes<T: PayloadTypes = SeismicPayloadTypes> { + _marker: core::marker::PhantomData<T>, +} + +impl< + T: PayloadTypes< + ExecutionData = ExecutionData, + BuiltPayload: BuiltPayload< + Primitives: NodePrimitives<Block = reth_seismic_primitives::SeismicBlock>, + >, + >, + > PayloadTypes for SeismicEngineTypes<T> +{ + type ExecutionData = T::ExecutionData; + type BuiltPayload = T::BuiltPayload; + type PayloadAttributes = T::PayloadAttributes; + type PayloadBuilderAttributes = T::PayloadBuilderAttributes; + + fn block_to_payload( + block: SealedBlock< + <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block, + >, + ) -> Self::ExecutionData { + let (payload, sidecar) = + ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block()); + ExecutionData { payload, sidecar } + } +} + +impl<T> EngineTypes for SeismicEngineTypes<T> +where + T: PayloadTypes<ExecutionData = ExecutionData>, + T::BuiltPayload: BuiltPayload<Primitives: NodePrimitives<Block = reth_seismic_primitives::SeismicBlock>> + + TryInto<ExecutionPayloadV1> + + TryInto<ExecutionPayloadEnvelopeV2> + + TryInto<ExecutionPayloadEnvelopeV3> + + TryInto<ExecutionPayloadEnvelopeV4> + + TryInto<ExecutionPayloadEnvelopeV5>, +{ + type ExecutionPayloadEnvelopeV1 = ExecutionPayloadV1; + type ExecutionPayloadEnvelopeV2 = ExecutionPayloadEnvelopeV2; + type ExecutionPayloadEnvelopeV3 = ExecutionPayloadEnvelopeV3; + type ExecutionPayloadEnvelopeV4 = ExecutionPayloadEnvelopeV4; + type ExecutionPayloadEnvelopeV5 = ExecutionPayloadEnvelopeV5; +} + +/// A default payload type for [`EthEngineTypes`] +#[derive(Debug, Default, Clone, serde::Deserialize, serde::Serialize)] +#[non_exhaustive] +pub struct SeismicPayloadTypes; + +impl PayloadTypes for SeismicPayloadTypes { + type BuiltPayload = EthBuiltPayload<SeismicPrimitives>; + type PayloadAttributes = PayloadAttributes; + type PayloadBuilderAttributes = EthPayloadBuilderAttributes; + type ExecutionData = ExecutionData; + + fn block_to_payload( + block: SealedBlock< + <<Self::BuiltPayload as BuiltPayload>::Primitives as NodePrimitives>::Block, + >, + ) -> Self::ExecutionData { + let (payload, sidecar) = + ExecutionPayload::from_block_unchecked(block.hash(), &block.into_block()); + ExecutionData { payload, sidecar } + } +} + +/// Validator for the ethereum engine API. +#[derive(Debug, Clone)] +pub struct SeismicEngineValidator { + inner: EthereumExecutionPayloadValidator<ChainSpec>, +} + +impl SeismicEngineValidator { + /// Instantiates a new validator. + pub const fn new(chain_spec: Arc<ChainSpec>) -> Self { + Self { inner: EthereumExecutionPayloadValidator::new(chain_spec) } + } + + /// Returns the chain spec used by the validator. + #[inline] + fn chain_spec(&self) -> &ChainSpec { + self.inner.chain_spec() + } +} + +impl PayloadValidator<SeismicEngineTypes> for SeismicEngineValidator { + type Block = reth_seismic_primitives::SeismicBlock; + + fn ensure_well_formed_payload( + &self, + payload: ExecutionData, + ) -> Result<RecoveredBlock<Self::Block>, NewPayloadError> { + let sealed_block = self.inner.ensure_well_formed_payload(payload)?; + sealed_block.try_recover().map_err(|e| NewPayloadError::Other(e.into())) + } +} + +impl<Types> EngineApiValidator<Types> for SeismicEngineValidator +where + Types: PayloadTypes<PayloadAttributes = PayloadAttributes, ExecutionData = ExecutionData>, +{ + fn validate_version_specific_fields( + &self, + version: EngineApiMessageVersion, + payload_or_attrs: PayloadOrAttributes<'_, ExecutionData, PayloadAttributes>, + ) -> Result<(), EngineObjectValidationError> { + payload_or_attrs + .execution_requests() + .map(|requests| validate_execution_requests(requests)) + .transpose()?; + + validate_version_specific_fields(self.chain_spec(), version, payload_or_attrs) + } + + fn ensure_well_formed_attributes( + &self, + version: EngineApiMessageVersion, + attributes: &PayloadAttributes, + ) -> Result<(), EngineObjectValidationError> { + validate_version_specific_fields( + self.chain_spec(), + version, + PayloadOrAttributes::<ExecutionData, PayloadAttributes>::PayloadAttributes(attributes), + ) + } +}

diff --git reth/crates/seismic/node/src/evm.rs seismic-reth/crates/seismic/node/src/evm.rs new file mode 100644 index 0000000000000000000000000000000000000000..4585ce0979457abdb5efa85dcfb37bff894bb58a --- /dev/null +++ seismic-reth/crates/seismic/node/src/evm.rs @@ -0,0 +1,8 @@ +//! Ethereum EVM support + +#[doc(inline)] +pub use reth_evm::execute::BasicBlockExecutorProvider; +#[doc(inline)] +pub use reth_evm_ethereum::execute::EthExecutorProvider; +#[doc(inline)] +pub use reth_evm_ethereum::{EthEvm, SeismicEvmConfig};

diff --git reth/crates/seismic/node/src/lib.rs seismic-reth/crates/seismic/node/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..31d82055f023bd0c6670eb9f938d707d828cffc5 --- /dev/null +++ seismic-reth/crates/seismic/node/src/lib.rs @@ -0,0 +1,35 @@ +//! Standalone crate for Seismic-specific Reth configuration and builder types. +//! +//! # features +//! - `js-tracer`: Enable the `JavaScript` tracer for the `debug_trace` endpoints + +#![doc( + html_logo_url = "https://raw.githubusercontent.com/paradigmxyz/reth/main/assets/reth-docs.png", + html_favicon_url = "https://avatars0.githubusercontent.com/u/97369466?s=256", + issue_tracker_base_url = "https://github.com/SeismicSystems/seismic-reth/issues/" +)] +#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))] +#![cfg_attr(not(test), warn(unused_crate_dependencies))] +// #![cfg_attr(not(feature = "std"), no_std)] + +pub mod enclave; +pub mod engine; +pub mod node; +pub mod purpose_keys; +pub use reth_seismic_txpool as txpool; +pub mod utils; + +pub use reth_seismic_payload_builder::SeismicPayloadBuilder; + +pub use reth_seismic_evm::*; + +use reth_chainspec::ChainSpec; +use std::sync::Arc; + +/// Creates a Seismic EVM configuration with the given chain spec and purpose keys. +pub fn seismic_evm_config( + spec: Arc<ChainSpec>, + purpose_keys: &'static seismic_enclave::GetPurposeKeysResponse, +) -> SeismicEvmConfig { + SeismicEvmConfig::new(spec, purpose_keys) +}

diff --git reth/crates/seismic/node/src/node.rs seismic-reth/crates/seismic/node/src/node.rs new file mode 100644 index 0000000000000000000000000000000000000000..c032fb1fbdd026770598710d715e22002c2fc9b1 --- /dev/null +++ seismic-reth/crates/seismic/node/src/node.rs @@ -0,0 +1,758 @@ +//! Seismic Node types config. + +use crate::{ + engine::{SeismicEngineTypes, SeismicEngineValidator}, + txpool::SeismicTransactionPool, +}; +use alloy_eips::merge::EPOCH_SLOTS; +use alloy_rpc_types_engine::ExecutionData; +use reth_chainspec::{ChainSpec, EthChainSpec}; +use reth_consensus::{ConsensusError, FullConsensus}; +use reth_engine_primitives::{NoopInvalidBlockHook, TreeConfig}; +use reth_eth_wire_types::NewBlock; +use reth_evm::{ + ConfigureEngineEvm, ConfigureEvm, EvmFactory, EvmFactoryFor, NextBlockEnvAttributes, +}; +use reth_network::{NetworkHandle, NetworkPrimitives}; +use reth_node_api::{AddOnsContext, FullNodeComponents, NodeAddOns, PrimitivesTy, TxTy}; +use reth_node_builder::{ + components::{ + BasicPayloadServiceBuilder, ComponentsBuilder, ConsensusBuilder, ExecutorBuilder, + NetworkBuilder, PayloadBuilderBuilder, PoolBuilder, + }, + node::{FullNodeTypes, NodeTypes}, + rpc::{ + BasicEngineApiBuilder, BasicEngineValidator, BasicEngineValidatorBuilder, EngineApiBuilder, + EngineValidatorAddOn, EngineValidatorBuilder, EthApiBuilder, PayloadValidatorBuilder, + RethRpcAddOns, RethRpcMiddleware, RpcAddOns, RpcHandle, RpcModuleContainer, + }, + BuilderContext, DebugNode, Node, NodeAdapter, NodeComponentsBuilder, PayloadBuilderConfig, +}; +use reth_node_ethereum::consensus::EthBeaconConsensus; +use reth_payload_primitives::PayloadAttributesBuilder; +use reth_provider::{providers::ProviderFactoryBuilder, CanonStateSubscriptions, EthStorage}; +use reth_rpc::ValidationApi; +use reth_rpc_api::BlockSubmissionValidationApiServer; +use reth_rpc_builder::{config::RethRpcServerConfig, Identity}; +use reth_rpc_eth_api::helpers::config::{EthConfigApiServer, EthConfigHandler}; +use reth_rpc_eth_types::{ + error::{api::FromEvmHalt, FromEvmError}, + EthApiError, +}; +use reth_rpc_server_types::RethRpcModule; +use reth_seismic_evm::SeismicEvmConfig; +use reth_seismic_payload_builder::SeismicBuilderConfig; +use reth_seismic_primitives::{SeismicPrimitives, SeismicReceipt, SeismicTransactionSigned}; +use reth_seismic_rpc::{ + ext::{EthApiExt, EthApiOverrideServer, SeismicApi, SeismicApiServer}, + SeismicEthApiBuilder, SeismicEthApiError, SeismicRethWithSignable, +}; +use reth_transaction_pool::{ + blobstore::{DiskFileBlobStore, DiskFileBlobStoreConfig}, + CoinbaseTipOrdering, PoolTransaction, TransactionPool, TransactionValidationTaskExecutor, +}; +use revm::context::TxEnv; +use seismic_alloy_consensus::SeismicTxEnvelope; +use std::{sync::Arc, time::SystemTime}; + +use crate::{purpose_keys::get_purpose_keys, seismic_evm_config}; + +/// Storage implementation for Seismic. +pub type SeismicStorage = EthStorage<SeismicTransactionSigned>; + +#[derive(Debug, Default, Clone)] +#[non_exhaustive] +/// Type configuration for a regular Seismic node. +pub struct SeismicNode; + +impl SeismicNode { + /// Returns the components for the given [`EnclaveArgs`]. + pub fn components<Node>( + &self, + ) -> ComponentsBuilder< + Node, + SeismicPoolBuilder, + BasicPayloadServiceBuilder<SeismicPayloadBuilder>, + SeismicNetworkBuilder, + SeismicExecutorBuilder, + SeismicConsensusBuilder, + > + where + Node: FullNodeTypes< + Types: NodeTypes< + Payload = SeismicEngineTypes, + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + >, + >, + { + ComponentsBuilder::default() + .node_types::<Node>() + .pool(SeismicPoolBuilder::default()) + .executor(SeismicExecutorBuilder::default()) + .payload(BasicPayloadServiceBuilder::<SeismicPayloadBuilder>::default()) + .network(SeismicNetworkBuilder::default()) + .executor(SeismicExecutorBuilder::default()) + .consensus(SeismicConsensusBuilder::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_chainspec::BASE_MAINNET; + /// use reth_seismic_node::SeismicNode; + /// + /// let factory = SeismicNode::provider_factory_builder() + /// .open_read_only(BASE_MAINNET.clone(), "datadir") + /// .unwrap(); + /// ``` + /// + /// # Open a Providerfactory manually with with all required components + /// + /// ```no_run + /// use reth_chainspec::ChainSpecBuilder; + /// use reth_db::open_db_read_only; + /// use reth_provider::providers::StaticFileProvider; + /// use reth_seismic_node::SeismicNode; + /// use std::sync::Arc; + /// + /// let factory = SeismicNode::provider_factory_builder() + /// .db(Arc::new(open_db_read_only("db", Default::default()).unwrap())) + /// .chainspec(ChainSpecBuilder::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 SeismicNode +where + N: FullNodeTypes< + Types: NodeTypes< + Payload = SeismicEngineTypes, + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + Storage = SeismicStorage, + >, + >, +{ + type ComponentsBuilder = ComponentsBuilder< + N, + SeismicPoolBuilder, + BasicPayloadServiceBuilder<SeismicPayloadBuilder>, + SeismicNetworkBuilder, + SeismicExecutorBuilder, + SeismicConsensusBuilder, + >; + + type AddOns = SeismicAddOns< + NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>, + SeismicEthApiBuilder<SeismicRethWithSignable>, + SeismicEngineValidatorBuilder, + BasicEngineApiBuilder<SeismicEngineValidatorBuilder>, + BasicEngineValidatorBuilder<SeismicEngineValidatorBuilder>, + Identity, + >; + + fn components_builder(&self) -> Self::ComponentsBuilder { + Self::components(self) + } + + fn add_ons(&self) -> Self::AddOns { + Self::AddOns::builder().build::< + NodeAdapter<N, <Self::ComponentsBuilder as NodeComponentsBuilder<N>>::Components>, + SeismicEthApiBuilder<SeismicRethWithSignable>, + SeismicEngineValidatorBuilder, + BasicEngineApiBuilder<SeismicEngineValidatorBuilder>, + BasicEngineValidatorBuilder<SeismicEngineValidatorBuilder>, + Identity + >() + } +} + +impl NodeTypes for SeismicNode { + type Primitives = SeismicPrimitives; + type ChainSpec = ChainSpec; + type Storage = SeismicStorage; + type Payload = SeismicEngineTypes; +} + +impl<N> DebugNode<N> for SeismicNode +where + N: FullNodeComponents<Types = Self>, +{ + type RpcBlock = alloy_rpc_types_eth::Block<seismic_alloy_consensus::SeismicTxEnvelope>; + + fn rpc_to_primitive_block(rpc_block: Self::RpcBlock) -> reth_node_api::BlockTy<Self> { + let alloy_rpc_types_eth::Block { header, transactions, .. } = rpc_block; + reth_seismic_primitives::SeismicBlock { + header: header.inner, + body: reth_seismic_primitives::SeismicBlockBody { + transactions: transactions.into_transactions().map(Into::into).collect(), + ..Default::default() + }, + } + } + + fn local_payload_attributes_builder( + chain_spec: &Self::ChainSpec, + ) -> impl PayloadAttributesBuilder< + <<Self as reth_node_api::NodeTypes>::Payload as reth_node_api::PayloadTypes>::PayloadAttributes, + >{ + reth_engine_local::LocalPayloadAttributesBuilder::new(Arc::new(chain_spec.clone())) + } +} + +/// Helper trait alias that bundles the common `FullNodeComponents` bounds required by Seismic +/// add-ons. This avoids repeating the verbose `NodeTypes` and `Evm` constraints across every +/// `impl` block. +pub trait SeismicFullNode: + FullNodeComponents< + Types: NodeTypes< + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + Storage = SeismicStorage, + Payload = SeismicEngineTypes, + >, + Evm: ConfigureEvm<NextBlockEnvCtx = NextBlockEnvAttributes>, +> +{ +} + +impl<N> SeismicFullNode for N where + N: FullNodeComponents< + Types: NodeTypes< + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + Storage = SeismicStorage, + Payload = SeismicEngineTypes, + >, + Evm: ConfigureEvm<NextBlockEnvCtx = NextBlockEnvAttributes>, + > +{ +} + +/// Add-ons w.r.t. seismic +#[derive(Debug)] +pub struct SeismicAddOns< + N: FullNodeComponents, + EthB: EthApiBuilder<N> = SeismicEthApiBuilder<SeismicRethWithSignable>, + PVB = SeismicEngineValidatorBuilder, + EB = BasicEngineApiBuilder<SeismicEngineValidatorBuilder>, + EVB = BasicEngineValidatorBuilder<SeismicEngineValidatorBuilder>, + RpcMiddleware = Identity, +> { + inner: RpcAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware>, +} + +impl<N, EthB, PVB, EB, EVB, RpcMiddleware> SeismicAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware> +where + N: SeismicFullNode, + EthB: EthApiBuilder<N>, +{ + /// Build a [`SeismicAddOns`] using [`SeismicAddOnsBuilder`]. + pub fn builder() -> SeismicAddOnsBuilder { + SeismicAddOnsBuilder::default() + } +} + +/// A regular seismic evm and executor builder. +#[derive(Debug, Default, Clone)] +pub struct SeismicAddOnsBuilder {} + +impl SeismicAddOnsBuilder { + /// Builds an instance of [`SeismicAddOns`]. + pub fn build<N, EthB, PVB, EB, EVB, RpcMiddleware>( + self, + ) -> SeismicAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware> + where + N: SeismicFullNode, + EthB: EthApiBuilder<N> + Default, + PVB: Default, + EB: Default, + EVB: Default, + RpcMiddleware: Default, + { + SeismicAddOns { + inner: RpcAddOns::new( + EthB::default(), + PVB::default(), + EB::default(), + EVB::default(), + RpcMiddleware::default(), + ), + } + } +} + +impl<N> Default for SeismicAddOns<N> +where + N: SeismicFullNode, + SeismicEthApiBuilder<SeismicRethWithSignable>: EthApiBuilder<N>, +{ + fn default() -> Self { + Self::builder().build::< + N, + SeismicEthApiBuilder<SeismicRethWithSignable>, + SeismicEngineValidatorBuilder, + BasicEngineApiBuilder<SeismicEngineValidatorBuilder>, + BasicEngineValidatorBuilder<SeismicEngineValidatorBuilder>, + Identity + >() + } +} + +impl<N, EthB, PVB, EB, EVB, RpcMiddleware> NodeAddOns<N> + for SeismicAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware> +where + N: SeismicFullNode, + EthB: EthApiBuilder<N>, + EthB::EthApi: reth_seismic_rpc::FullSeismicApi + Send + Sync + 'static, + <EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error: Send + Sync + 'static, + jsonrpsee::types::ErrorObject<'static>: + From<<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error>, + <<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::NetworkTypes as reth_rpc_eth_api::RpcTypes>::TransactionRequest: + From<alloy_rpc_types::TransactionRequest> + + AsRef<alloy_rpc_types::TransactionRequest> + + Send + + Sync + + 'static, + PVB: PayloadValidatorBuilder<N>, + EB: EngineApiBuilder<N>, + EVB: EngineValidatorBuilder<N>, + RpcMiddleware: RethRpcMiddleware, + EthApiError: FromEvmError<N::Evm>, + SeismicEthApiError: + FromEvmError<N::Evm> + FromEvmHalt<<EvmFactoryFor<N::Evm> as EvmFactory>::HaltReason>, + EvmFactoryFor<N::Evm>: EvmFactory<Tx = seismic_revm::SeismicTransaction<TxEnv>>, +{ + type Handle = RpcHandle<N, EthB::EthApi>; + + async fn launch_add_ons( + self, + ctx: reth_node_api::AddOnsContext<'_, N>, + ) -> eyre::Result<Self::Handle> { + let validation_api = ValidationApi::new( + ctx.node.provider().clone(), + Arc::new(ctx.node.consensus().clone()), + ctx.node.evm_config().clone(), + ctx.config.rpc.flashbots_config(), + Box::new(ctx.node.task_executor().clone()), + Arc::new(SeismicEngineValidator::new(ctx.config.chain.clone())), + ); + + let eth_config = + EthConfigHandler::new(ctx.node.provider().clone(), ctx.node.evm_config().clone()); + + let purpose_keys = get_purpose_keys().clone(); + + self.inner + .launch_add_ons_with(ctx, move |container| { + let RpcModuleContainer { modules, registry, .. } = container; + modules.merge_if_module_configured( + RethRpcModule::Flashbots, + validation_api.into_rpc(), + )?; + + modules.merge_if_module_configured(RethRpcModule::Eth, eth_config.into_rpc())?; + + // Register Seismic eth_ overrides (sendRawTransaction, call, estimateGas, etc.) + modules.replace_configured( + EthApiExt::new(registry.eth_api().clone(), purpose_keys.clone()).into_rpc(), + )?; + + // Register seismic_ namespace (getTeePublicKey) + modules.merge_configured(SeismicApi::new(purpose_keys).into_rpc())?; + + Ok(()) + }) + .await + } +} + +impl<N, EthB, PVB, EB, EVB, RpcMiddleware> RethRpcAddOns<N> + for SeismicAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware> +where + N: SeismicFullNode, + EthB: EthApiBuilder<N>, + EthB::EthApi: reth_seismic_rpc::FullSeismicApi + Send + Sync + 'static, + <EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error: Send + Sync + 'static, + jsonrpsee::types::ErrorObject<'static>: + From<<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error>, + <<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::NetworkTypes as reth_rpc_eth_api::RpcTypes>::TransactionRequest: + From<alloy_rpc_types::TransactionRequest> + + AsRef<alloy_rpc_types::TransactionRequest> + + Send + + Sync + + 'static, + PVB: PayloadValidatorBuilder<N>, + EB: EngineApiBuilder<N>, + EVB: EngineValidatorBuilder<N>, + RpcMiddleware: RethRpcMiddleware, + EthApiError: FromEvmError<N::Evm>, + SeismicEthApiError: FromEvmError<N::Evm>, + EvmFactoryFor<N::Evm>: EvmFactory<Tx = seismic_revm::SeismicTransaction<TxEnv>>, +{ + type EthApi = EthB::EthApi; + + fn hooks_mut(&mut self) -> &mut reth_node_builder::rpc::RpcHooks<N, Self::EthApi> { + self.inner.hooks_mut() + } +} + +impl<N, EthB, PVB, EB, EVB, RpcMiddleware> EngineValidatorAddOn<N> + for SeismicAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware> +where + N: SeismicFullNode<Evm: ConfigureEngineEvm<ExecutionData>>, + EthB: EthApiBuilder<N>, + EthB::EthApi: reth_seismic_rpc::FullSeismicApi + Send + Sync + 'static, + <EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error: Send + Sync + 'static, + jsonrpsee::types::ErrorObject<'static>: + From<<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::Error>, + <<EthB::EthApi as reth_rpc_eth_api::EthApiTypes>::NetworkTypes as reth_rpc_eth_api::RpcTypes>::TransactionRequest: + From<alloy_rpc_types::TransactionRequest> + + AsRef<alloy_rpc_types::TransactionRequest> + + Send + + Sync + + 'static, + PVB: PayloadValidatorBuilder<N>, + EB: EngineApiBuilder<N>, + EVB: EngineValidatorBuilder<N> + Send, + RpcMiddleware: Send, +{ + type ValidatorBuilder = EVB; + + fn engine_validator_builder(&self) -> Self::ValidatorBuilder { + EngineValidatorAddOn::engine_validator_builder(&self.inner) + } +} + +/// A regular seismic evm and executor builder. +#[derive(Debug, Default, Clone, Copy)] +#[non_exhaustive] +pub struct SeismicExecutorBuilder; + +impl<Node> ExecutorBuilder<Node> for SeismicExecutorBuilder +where + Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec, Primitives = SeismicPrimitives>>, +{ + type EVM = SeismicEvmConfig; + + async fn build_evm(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::EVM> { + let purpose_keys = crate::purpose_keys::get_purpose_keys(); + let evm_config = seismic_evm_config(ctx.chain_spec(), purpose_keys); + + Ok(evm_config) + } +} + +/// A basic ethereum transaction pool. +/// +/// This contains various settings that can be configured and take precedence over the node's +/// config. +#[derive(Debug, Default, Clone, Copy)] +#[non_exhaustive] +pub struct SeismicPoolBuilder; + +impl<Node> PoolBuilder<Node> for SeismicPoolBuilder +where + Node: FullNodeTypes< + Types: NodeTypes< + Payload = SeismicEngineTypes, + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + >, + >, + // T: EthPoolTransaction<Consensus = TxTy<Node::Types>> + // + MaybeConditionalTransaction + // + MaybeInteropTransaction, +{ + type Pool = SeismicTransactionPool<Node::Provider, DiskFileBlobStore>; + + async fn build_pool(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Pool> { + let data_dir = ctx.config().datadir(); + let pool_config = ctx.pool_config(); + + let blob_cache_size = if let Some(blob_cache_size) = pool_config.blob_cache_size { + blob_cache_size + } else { + // get the current blob params for the current timestamp + let current_timestamp = + SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?.as_secs(); + let blob_params = ctx + .chain_spec() + .blob_params_at_timestamp(current_timestamp) + .unwrap_or(ctx.chain_spec().blob_params.cancun); + + // Derive the blob cache size from the target blob count, to auto scale it by + // multiplying it with the slot count for 2 epochs: 384 for pectra + (blob_params.target_blob_count * EPOCH_SLOTS * 2) as u32 + }; + + let custom_config = + DiskFileBlobStoreConfig::default().with_max_cached_entries(blob_cache_size); + + let blob_store = DiskFileBlobStore::open(data_dir.blobstore(), custom_config)?; + let head_timestamp_seconds = if cfg!(feature = "timestamp-in-seconds") { + ctx.head().timestamp + } else { + ctx.head().timestamp / 1000 + }; + let eth_validator = TransactionValidationTaskExecutor::eth_builder(ctx.provider().clone()) + .with_head_timestamp(head_timestamp_seconds) + .kzg_settings(ctx.kzg_settings()?) + .with_local_transactions_config(pool_config.local_transactions_config.clone()) + .with_additional_tasks(ctx.config().txpool.additional_validation_tasks) + // Gas is paid in USDC on Seismic, not native ETH. Disable the native balance check + // so transactions from accounts with zero ETH are not rejected. Actual gas payment + // is enforced by the Seismic revm implementation at execution time. + .disable_balance_check() + .build_with_tasks(ctx.task_executor().clone(), blob_store.clone()); + + // Wrap the eth validator with seismic-specific validation + let validator = eth_validator.map(reth_seismic_txpool::SeismicTransactionValidator::new); + + let transaction_pool = reth_transaction_pool::Pool::new( + validator, + CoinbaseTipOrdering::default(), + blob_store, + pool_config, + ); + // info!(target: "reth::cli", "Transaction pool initialized"); + let transactions_path = data_dir.txpool_transactions(); + + // spawn txpool maintenance task + { + 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 maintenance task with USDC balance augmentation + let balance_hook = reth_seismic_txpool::SeismicBalanceHook; + ctx.task_executor().spawn_critical( + "txpool maintenance task", + reth_transaction_pool::maintain::maintain_transaction_pool_future_with_hook( + client, + pool, + chain_events, + ctx.task_executor().clone(), + reth_transaction_pool::maintain::MaintainPoolConfig { + max_tx_lifetime: transaction_pool.config().max_queued_lifetime, + ..Default::default() + }, + balance_hook, + ), + ); + // debug!(target: "reth::cli", "Spawned txpool maintenance task"); + } + + Ok(transaction_pool) + } +} + +/// A basic seismic payload service builder +#[derive(Debug, Default, Clone)] +pub struct SeismicPayloadBuilder; + +impl SeismicPayloadBuilder { + /// A helper method initializing [`reth_ethereum_payload_builder::EthereumPayloadBuilder`] + /// with the given EVM config. + pub fn build<Types, Node, Evm, Pool>( + self, + evm_config: Evm, + ctx: &BuilderContext<Node>, + pool: Pool, + ) -> eyre::Result<reth_seismic_payload_builder::SeismicPayloadBuilder<Pool, Node::Provider, Evm>> + where + Node: FullNodeTypes< + Types: NodeTypes< + Payload = SeismicEngineTypes, + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + >, + >, + Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>> + + Unpin + + 'static, + Evm: ConfigureEvm<Primitives = PrimitivesTy<Node::Types>>, + // Txs: SeismicPayloadTransactions<Pool::Transaction>, + { + let conf = ctx.payload_builder_config(); + let chain = ctx.chain_spec().chain(); + let gas_limit = conf.gas_limit_for(chain); + + Ok(reth_seismic_payload_builder::SeismicPayloadBuilder::new( + ctx.provider().clone(), + pool, + evm_config, + SeismicBuilderConfig::new().with_gas_limit(gas_limit), + )) + } +} + +impl<Node, Pool> PayloadBuilderBuilder<Node, Pool, SeismicEvmConfig> for SeismicPayloadBuilder +where + Node: FullNodeTypes< + Types: NodeTypes< + Payload = SeismicEngineTypes, + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + >, + >, + Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>> + + Unpin + + 'static, +{ + type PayloadBuilder = + reth_seismic_payload_builder::SeismicPayloadBuilder<Pool, Node::Provider, SeismicEvmConfig>; + + async fn build_payload_builder( + self, + ctx: &BuilderContext<Node>, + pool: Pool, + evm_config: SeismicEvmConfig, + ) -> eyre::Result<Self::PayloadBuilder> { + let conf = ctx.payload_builder_config(); + let chain = ctx.chain_spec().chain(); + let gas_limit = conf.gas_limit_for(chain); + + let payload_builder = reth_seismic_payload_builder::SeismicPayloadBuilder::new( + ctx.provider().clone(), + pool, + evm_config, + SeismicBuilderConfig::new().with_gas_limit(gas_limit), + ); + Ok(payload_builder) + } +} + +/// A basic ethereum payload service. +#[derive(Debug, Default, Clone, Copy)] +pub struct SeismicNetworkBuilder { + // TODO add closure to modify network +} + +impl<Node, Pool> NetworkBuilder<Node, Pool> for SeismicNetworkBuilder +where + Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec, Primitives = SeismicPrimitives>>, + Pool: TransactionPool< + Transaction: PoolTransaction<Consensus = TxTy<Node::Types>, Pooled = SeismicTxEnvelope>, /* equiv to op_alloy_consensus::OpPooledTransaction>, */ + > + Unpin + + 'static, +{ + type Network = NetworkHandle<SeismicNetworkPrimitives>; + + async fn build_network( + self, + ctx: &BuilderContext<Node>, + pool: Pool, + ) -> eyre::Result<NetworkHandle<SeismicNetworkPrimitives>> { + let network = ctx.network_builder().await?; + let handle = ctx.start_network(network, pool); + // info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking + // initialized"); + Ok(handle) + } +} + +/// A basic seismic consensus builder. +#[derive(Debug, Default, Clone)] +#[non_exhaustive] +pub struct SeismicConsensusBuilder; + +impl<Node> ConsensusBuilder<Node> for SeismicConsensusBuilder +where + Node: FullNodeTypes<Types: NodeTypes<ChainSpec = ChainSpec, Primitives = SeismicPrimitives>>, +{ + type Consensus = Arc<dyn FullConsensus<SeismicPrimitives, Error = ConsensusError>>; + + async fn build_consensus(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Consensus> { + Ok(Arc::new(EthBeaconConsensus::new(ctx.chain_spec()))) + } +} + +/// Builder for [`EthereumEngineValidator`]. +#[derive(Debug, Default, Clone)] +#[non_exhaustive] +pub struct SeismicEngineValidatorBuilder; + +impl<Node, Types> EngineValidatorBuilder<Node> for SeismicEngineValidatorBuilder +where + Types: NodeTypes< + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + Payload = SeismicEngineTypes, + >, + Node: FullNodeComponents<Types = Types>, + Node::Evm: ConfigureEngineEvm<ExecutionData>, +{ + type EngineValidator = BasicEngineValidator<Node::Provider, Node::Evm, SeismicEngineValidator>; + + async fn build_tree_validator( + self, + ctx: &AddOnsContext<'_, Node>, + tree_config: TreeConfig, + ) -> eyre::Result<Self::EngineValidator> { + let seismic_validator = SeismicEngineValidator::new(ctx.config.chain.clone()); + Ok(BasicEngineValidator::new( + ctx.node.provider().clone(), + Arc::new(ctx.node.consensus().clone()), + ctx.node.evm_config().clone(), + seismic_validator, + tree_config, + Box::new(NoopInvalidBlockHook::default()), + )) + } +} + +impl<Node> PayloadValidatorBuilder<Node> for SeismicEngineValidatorBuilder +where + Node: FullNodeComponents< + Types: NodeTypes< + ChainSpec = ChainSpec, + Primitives = SeismicPrimitives, + Payload = SeismicEngineTypes, + >, + >, +{ + type Validator = SeismicEngineValidator; + + async fn build(self, ctx: &AddOnsContext<'_, Node>) -> eyre::Result<Self::Validator> { + Ok(SeismicEngineValidator::new(ctx.config.chain.clone())) + } +} +/// Network primitive types used by Seismic network. +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)] +#[non_exhaustive] +pub struct SeismicNetworkPrimitives; + +impl NetworkPrimitives for SeismicNetworkPrimitives { + type BlockHeader = alloy_consensus::Header; + type BlockBody = alloy_consensus::BlockBody<SeismicTransactionSigned>; + type Block = alloy_consensus::Block<SeismicTransactionSigned>; + type BroadcastedTransaction = SeismicTransactionSigned; + type PooledTransaction = SeismicTxEnvelope; + type Receipt = SeismicReceipt; + type NewBlockPayload = NewBlock<Self::Block>; +}

diff --git reth/crates/seismic/node/src/purpose_keys.rs seismic-reth/crates/seismic/node/src/purpose_keys.rs new file mode 100644 index 0000000000000000000000000000000000000000..d2bb08b4f4e0b3f2aa17ea924266a9aaa87050b8 --- /dev/null +++ seismic-reth/crates/seismic/node/src/purpose_keys.rs @@ -0,0 +1,30 @@ +//! Global storage for purpose keys fetched from enclave on boot. +//! +//! This module provides thread-safe access to purpose keys that are fetched once +//! during node startup and then used throughout the application lifetime. + +use seismic_enclave::GetPurposeKeysResponse; +use std::sync::OnceLock; + +/// Global storage for purpose keys. +/// These keys are fetched once from the enclave during node startup. +static PURPOSE_KEYS: OnceLock<GetPurposeKeysResponse> = OnceLock::new(); + +/// Initialize the global purpose keys. +/// This should be called once during node startup, after the enclave is booted. +/// +/// # Panics +/// Panics if called more than once. +#[allow(clippy::expect_used)] // Documented panic behavior +pub fn init_purpose_keys(keys: GetPurposeKeysResponse) { + PURPOSE_KEYS.set(keys).expect("Purpose keys already initialized"); +} + +/// Get a reference to the purpose keys. +/// +/// # Panics +/// Panics if the keys haven't been initialized yet. +#[allow(clippy::expect_used)] // Documented panic behavior +pub fn get_purpose_keys() -> &'static GetPurposeKeysResponse { + PURPOSE_KEYS.get().expect("Purpose keys not initialized") +}

diff --git reth/crates/seismic/node/src/utils.rs seismic-reth/crates/seismic/node/src/utils.rs new file mode 100644 index 0000000000000000000000000000000000000000..449a6a2b33bcd10bdaabcf7b156e9ae12521e2d6 --- /dev/null +++ seismic-reth/crates/seismic/node/src/utils.rs @@ -0,0 +1,135 @@ +//! Test utilities for Seismic E2E tests. + +#![allow(clippy::unwrap_used, clippy::expect_used)] // Test utilities - panics are acceptable + +/// E2E test helpers: node setup, chain advancement, payload attributes. +#[cfg(feature = "test-utils")] +pub mod e2e { + use crate::{node::SeismicNode, purpose_keys::init_purpose_keys}; + use alloy_primitives::{Address, B256}; + use alloy_rpc_types_engine::PayloadAttributes; + use reth_e2e_test_utils::{ + transaction::TransactionTestContext, wallet::Wallet, NodeHelperType, TmpDB, + }; + use reth_node_api::NodeTypesWithDBAdapter; + use reth_payload_builder::{EthBuiltPayload, EthPayloadBuilderAttributes}; + use reth_provider::providers::BlockchainProvider; + use reth_seismic_chainspec::SEISMIC_DEV; + use reth_seismic_primitives::SeismicPrimitives; + use reth_tasks::TaskManager; + use seismic_enclave::{ + get_unsecure_sample_schnorrkel_keypair, get_unsecure_sample_secp256k1_pk, + get_unsecure_sample_secp256k1_sk, GetPurposeKeysResponse, + }; + use std::sync::{Arc, Once}; + use tokio::sync::Mutex; + + /// Seismic returns times in milliseconds + pub const SEISMIC_TIMESTAMP_MULTIPLIER: u64 = 1000; + + static INIT_KEYS: Once = Once::new(); + + /// Initializes mock purpose keys for tests. Safe to call multiple times. + pub fn ensure_mock_purpose_keys() { + INIT_KEYS.call_once(|| { + init_purpose_keys(GetPurposeKeysResponse { + tx_io_sk: get_unsecure_sample_secp256k1_sk(), + tx_io_pk: get_unsecure_sample_secp256k1_pk(), + snapshot_key_bytes: [0u8; 32], + rng_keypair: get_unsecure_sample_schnorrkel_keypair(), + }); + }); + } + + /// Seismic Node Helper type + pub type SeismicTestNode = + NodeHelperType<SeismicNode, BlockchainProvider<NodeTypesWithDBAdapter<SeismicNode, TmpDB>>>; + + /// Creates the initial setup with `num_nodes` of the seismic node config, started and + /// connected. + pub async fn setup( + num_nodes: usize, + ) -> eyre::Result<(Vec<SeismicTestNode>, TaskManager, Wallet)> { + reth_e2e_test_utils::setup_engine( + num_nodes, + SEISMIC_DEV.clone(), + false, + Default::default(), + seismic_payload_attributes, + ) + .await + } + + /// Advance the chain with sequential payloads returning them in the end. + pub async fn advance_chain( + length: usize, + node: &mut SeismicTestNode, + wallet: Arc<Mutex<Wallet>>, + ) -> eyre::Result<Vec<EthBuiltPayload<SeismicPrimitives>>> { + node.advance(length as u64, |_| { + let wallet = wallet.clone(); + Box::pin(async move { + let mut wallet = wallet.lock().await; + let nonce = wallet.inner_nonce; + wallet.inner_nonce += 1; + let tx = alloy_rpc_types_eth::TransactionRequest { + nonce: Some(nonce), + value: Some(alloy_primitives::U256::from(100)), + to: Some(alloy_primitives::TxKind::Call(Address::random())), + gas: Some(21000), + max_fee_per_gas: Some(20e9 as u128), + max_priority_fee_per_gas: Some(20e9 as u128), + chain_id: Some(wallet.chain_id), + ..Default::default() + }; + let signed = TransactionTestContext::sign_tx(wallet.inner.clone(), tx).await; + alloy_eips::eip2718::Encodable2718::encoded_2718(&signed).into() + }) + }) + .await + } + + /// Helper function to create a new eth payload attributes for seismic + pub fn seismic_payload_attributes(timestamp: u64) -> EthPayloadBuilderAttributes { + let attributes = PayloadAttributes { + timestamp: timestamp * SEISMIC_TIMESTAMP_MULTIPLIER, + prev_randao: B256::ZERO, + suggested_fee_recipient: Address::ZERO, + withdrawals: Some(vec![]), + parent_beacon_block_root: Some(B256::ZERO), + }; + EthPayloadBuilderAttributes::new(B256::ZERO, attributes) + } +} + +/// RPC test utilities: nonce helpers, re-exported test helpers. +pub mod test_utils { + use alloy_primitives::Address; + use alloy_rpc_types::{Block, Header, Transaction, TransactionReceipt}; + use jsonrpsee::http_client::HttpClient; + use reth_rpc_eth_api::EthApiClient; + use seismic_alloy_rpc_types::SeismicTransactionRequest; + + pub use reth_seismic_primitives::test_utils::{ + client_decrypt, client_encrypt, get_ciphertext, get_client_io_sk, get_encryption_nonce, + get_network_public_key, get_plaintext, get_seismic_elements, get_seismic_metadata, + get_seismic_tx, get_signed_seismic_tx, get_signed_seismic_tx_bytes, + get_signed_seismic_tx_encoding, get_signed_seismic_tx_typed_data, get_signing_private_key, + get_unsigned_seismic_tx_request, get_unsigned_seismic_tx_typed_data, get_wrong_private_key, + sign_seismic_tx, sign_tx, + }; + + /// Get the nonce from the client + pub async fn get_nonce(client: &HttpClient, address: Address) -> u64 { + let nonce = EthApiClient::< + SeismicTransactionRequest, + Transaction, + Block, + TransactionReceipt, + Header, + >::transaction_count(client, address, None) + .await + .unwrap(); + nonce.wrapping_to::<u64>() + } +}

diff --git reth/crates/seismic/node/tests/assets/genesis.json seismic-reth/crates/seismic/node/tests/assets/genesis.json new file mode 100644 index 0000000000000000000000000000000000000000..e59d90f4ff10ea3f4c49903080a63c47973fd8d0 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/assets/genesis.json @@ -0,0 +1 @@ +{"config":{"chainId":8453,"homesteadBlock":0,"eip150Block":0,"eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"constantinopleBlock":0,"petersburgBlock":0,"istanbulBlock":0,"muirGlacierBlock":0,"berlinBlock":0,"londonBlock":0,"arrowGlacierBlock":0,"grayGlacierBlock":0,"mergeNetsplitBlock":0,"bedrockBlock":0,"regolithTime":0,"terminalTotalDifficulty":0,"terminalTotalDifficultyPassed":true,"optimism":{"eip1559Elasticity":6,"eip1559Denominator":50}},"nonce":"0x0","timestamp":"0x0","extraData":"0x00","gasLimit":"0x1c9c380","difficulty":"0x0","mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000","coinbase":"0x0000000000000000000000000000000000000000","alloc":{"0x14dc79964da2c08b23698b3d3cc7ca32193d9955":{"balance":"0xd3c21bcecceda1000000"},"0x15d34aaf54267db7d7c367839aaf71a00a2c6a65":{"balance":"0xd3c21bcecceda1000000"},"0x1cbd3b2770909d4e10f157cabc84c7264073c9ec":{"balance":"0xd3c21bcecceda1000000"},"0x23618e81e3f5cdf7f54c3d65f7fbc0abf5b21e8f":{"balance":"0xd3c21bcecceda1000000"},"0x2546bcd3c84621e976d8185a91a922ae77ecec30":{"balance":"0xd3c21bcecceda1000000"},"0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc":{"balance":"0xd3c21bcecceda1000000"},"0x70997970c51812dc3a010c7d01b50e0d17dc79c8":{"balance":"0xd3c21bcecceda1000000"},"0x71be63f3384f5fb98995898a86b02fb2426c5788":{"balance":"0xd3c21bcecceda1000000"},"0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199":{"balance":"0xd3c21bcecceda1000000"},"0x90f79bf6eb2c4f870365e785982e1f101e93b906":{"balance":"0xd3c21bcecceda1000000"},"0x976ea74026e726554db657fa54763abd0c3a0aa9":{"balance":"0xd3c21bcecceda1000000"},"0x9965507d1a55bcc2695c58ba16fb37d819b0a4dc":{"balance":"0xd3c21bcecceda1000000"},"0x9c41de96b2088cdc640c6182dfcf5491dc574a57":{"balance":"0xd3c21bcecceda1000000"},"0xa0ee7a142d267c1f36714e4a8f75612f20a79720":{"balance":"0xd3c21bcecceda1000000"},"0xbcd4042de499d14e55001ccbb24a551f3b954096":{"balance":"0xd3c21bcecceda1000000"},"0xbda5747bfd65f08deb54cb465eb87d40e51b197e":{"balance":"0xd3c21bcecceda1000000"},"0xcd3b766ccdd6ae721141f452c550ca635964ce71":{"balance":"0xd3c21bcecceda1000000"},"0xdd2fd4581271e230360230f9337d5c0430bf44c0":{"balance":"0xd3c21bcecceda1000000"},"0xdf3e18d64bc6a983f673ab319ccae4f1a57c7097":{"balance":"0xd3c21bcecceda1000000"},"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266":{"balance":"0xd3c21bcecceda1000000"},"0xfabb0ac9d68b0b445fb7357272ff202c5651694a":{"balance":"0xd3c21bcecceda1000000"}},"number":"0x0"} \ No newline at end of file

diff --git reth/crates/seismic/node/tests/e2e/blobs.rs seismic-reth/crates/seismic/node/tests/e2e/blobs.rs new file mode 100644 index 0000000000000000000000000000000000000000..69e4a9d18db1163e7c45f9fc52e0d60dfdb24f56 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/blobs.rs @@ -0,0 +1,84 @@ +use crate::utils::eth_payload_attributes; +use alloy_genesis::Genesis; +use reth_chainspec::{ChainSpecBuilder, MAINNET}; +use reth_e2e_test_utils::{ + node::NodeTestContext, transaction::TransactionTestContext, wallet::Wallet, +}; +use reth_node_builder::{NodeBuilder, NodeHandle}; +use reth_node_core::{args::RpcServerArgs, node_config::NodeConfig}; +use reth_node_ethereum::EthereumNode; +use reth_tasks::TaskManager; +use reth_transaction_pool::TransactionPool; +use std::sync::Arc; + +#[tokio::test(flavor = "multi_thread")] +async fn can_handle_blobs() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + let tasks = TaskManager::current(); + let exec = tasks.executor(); + + let genesis: Genesis = serde_json::from_str(include_str!("../assets/genesis.json")).unwrap(); + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(genesis) + .cancun_activated() + .build(), + ); + let genesis_hash = chain_spec.genesis_hash(); + let node_config = NodeConfig::test() + .with_chain(chain_spec) + .with_unused_ports() + .with_rpc(RpcServerArgs::default().with_unused_ports().with_http()); + let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config.clone()) + .testing_node(exec.clone()) + .node(EthereumNode::default()) + .launch() + .await?; + + let mut node = NodeTestContext::new(node, eth_payload_attributes).await?; + + let wallets = Wallet::new(2).gen(); + let blob_wallet = wallets.first().unwrap(); + let second_wallet = wallets.last().unwrap(); + + // inject normal tx + let raw_tx = TransactionTestContext::transfer_tx_bytes(1, second_wallet.clone()).await; + let tx_hash = node.rpc.inject_tx(raw_tx).await?; + // build payload with normal tx + let payload = node.new_payload().await?; + + // clean the pool + node.inner.pool.remove_transactions(vec![tx_hash]); + + // build blob tx + let blob_tx = TransactionTestContext::tx_with_blobs_bytes(1, blob_wallet.clone()).await?; + + // inject blob tx to the pool + let blob_tx_hash = node.rpc.inject_tx(blob_tx).await?; + // fetch it from rpc + let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?; + // validate sidecar + TransactionTestContext::validate_sidecar(envelope); + + // build a payload + let blob_payload = node.new_payload().await?; + + // submit the blob payload + let blob_block_hash = node.submit_payload(blob_payload).await?; + + node.update_forkchoice(genesis_hash, blob_block_hash).await?; + + // submit normal payload (reorg) + let block_hash = node.submit_payload(payload).await?; + node.update_forkchoice(genesis_hash, block_hash).await?; + + tokio::time::sleep(std::time::Duration::from_secs(3)).await; + + // expects the blob tx to be back in the pool + let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?; + // make sure the sidecar is present + TransactionTestContext::validate_sidecar(envelope); + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/dev.rs seismic-reth/crates/seismic/node/tests/e2e/dev.rs new file mode 100644 index 0000000000000000000000000000000000000000..7231d4f77a5970d950523d982e08b68d174dc30c --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/dev.rs @@ -0,0 +1,113 @@ +use alloy_eips::eip2718::Encodable2718; +use alloy_genesis::Genesis; +use alloy_primitives::{b256, hex}; +use futures::StreamExt; +use reth_chainspec::ChainSpec; +use reth_node_api::{BlockBody, FullNodeComponents, FullNodePrimitives, NodeTypes}; +use reth_node_builder::{ + rpc::RethRpcAddOns, EngineNodeLauncher, FullNode, NodeBuilder, NodeConfig, NodeHandle, +}; +use reth_node_core::args::DevArgs; +use reth_node_ethereum::{node::EthereumAddOns, EthereumNode}; +use reth_provider::{providers::BlockchainProvider, CanonStateSubscriptions}; +use reth_rpc_eth_api::helpers::EthTransactions; +use reth_tasks::TaskManager; +use std::sync::Arc; + +#[tokio::test(flavor = "multi_thread")] +async fn can_run_dev_node() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + let tasks = TaskManager::current(); + let exec = tasks.executor(); + + let node_config = NodeConfig::test() + .with_chain(custom_chain()) + .with_dev(DevArgs { dev: true, ..Default::default() }); + let NodeHandle { node, .. } = NodeBuilder::new(node_config.clone()) + .testing_node(exec.clone()) + .with_types_and_provider::<EthereumNode, BlockchainProvider<_>>() + .with_components(EthereumNode::components()) + .with_add_ons(EthereumAddOns::default()) + .launch_with_fn(|builder| { + let launcher = EngineNodeLauncher::new( + builder.task_executor().clone(), + builder.config().datadir(), + Default::default(), + ); + builder.launch_with(launcher) + }) + .await?; + + assert_chain_advances(node).await; + + Ok(()) +} + +async fn assert_chain_advances<N, AddOns>(node: FullNode<N, AddOns>) +where + N: FullNodeComponents<Provider: CanonStateSubscriptions>, + AddOns: RethRpcAddOns<N, EthApi: EthTransactions>, + N::Types: NodeTypes<Primitives: FullNodePrimitives>, +{ + let mut notifications = node.provider.canonical_state_stream(); + + // submit tx through rpc + let raw_tx = hex!("02f876820a28808477359400847735940082520894ab0840c0e43688012c1adb0f5e3fc665188f83d28a029d394a5d630544000080c080a0a044076b7e67b5deecc63f61a8d7913fab86ca365b344b5759d1fe3563b4c39ea019eab979dd000da04dfc72bb0377c092d30fd9e1cab5ae487de49586cc8b0090"); + + let eth_api = node.rpc_registry.eth_api(); + + let hash = eth_api.send_raw_transaction(raw_tx.into()).await.unwrap(); + + let expected = b256!("0xb1c6512f4fc202c04355fbda66755e0e344b152e633010e8fd75ecec09b63398"); + + assert_eq!(hash, expected); + println!("submitted transaction: {hash}"); + + let head = notifications.next().await.unwrap(); + + let tx = &head.tip().body().transactions()[0]; + assert_eq!(tx.trie_hash(), hash); + println!("mined transaction: {hash}"); +} + +fn custom_chain() -> Arc<ChainSpec> { + let custom_genesis = r#" +{ + + "nonce": "0x42", + "timestamp": "0x0", + "extraData": "0x5343", + "gasLimit": "0x13880", + "difficulty": "0x400000000", + "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "coinbase": "0x0000000000000000000000000000000000000000", + "alloc": { + "0x6Be02d1d3665660d22FF9624b7BE0551ee1Ac91b": { + "balance": "0x4a47e3c12448f4ad000000" + } + }, + "number": "0x0", + "gasUsed": "0x0", + "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "config": { + "ethash": {}, + "chainId": 2600, + "homesteadBlock": 0, + "eip150Block": 0, + "eip155Block": 0, + "eip158Block": 0, + "byzantiumBlock": 0, + "constantinopleBlock": 0, + "petersburgBlock": 0, + "istanbulBlock": 0, + "berlinBlock": 0, + "londonBlock": 0, + "terminalTotalDifficulty": 0, + "terminalTotalDifficultyPassed": true, + "shanghaiTime": 0 + } +} +"#; + let genesis: Genesis = serde_json::from_str(custom_genesis).unwrap(); + Arc::new(genesis.into()) +}

diff --git reth/crates/seismic/node/tests/e2e/eth.rs seismic-reth/crates/seismic/node/tests/e2e/eth.rs new file mode 100644 index 0000000000000000000000000000000000000000..f925183ec931f5d2e209cf26f65aabdedda3ae53 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/eth.rs @@ -0,0 +1,129 @@ +use crate::utils::eth_payload_attributes; +use alloy_genesis::Genesis; +use reth_chainspec::{ChainSpecBuilder, MAINNET}; +use reth_e2e_test_utils::{ + node::NodeTestContext, setup, transaction::TransactionTestContext, wallet::Wallet, +}; +use reth_node_builder::{NodeBuilder, NodeHandle}; +use reth_node_core::{args::RpcServerArgs, node_config::NodeConfig}; +use reth_node_ethereum::EthereumNode; +use reth_tasks::TaskManager; +use std::sync::Arc; + +#[tokio::test(flavor = "multi_thread")] +async fn can_run_eth_node() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let (mut nodes, _tasks, wallet) = setup::<EthereumNode>( + 1, + Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .cancun_activated() + .build(), + ), + false, + eth_payload_attributes, + ) + .await?; + + let mut node = nodes.pop().unwrap(); + let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).await; + + // make the node advance + let tx_hash = node.rpc.inject_tx(raw_tx).await?; + + // make the node advance + let payload = node.advance_block().await?; + + let block_hash = payload.block().hash(); + let block_number = payload.block().number; + + // assert the block has been committed to the blockchain + node.assert_new_block(tx_hash, block_hash, block_number).await?; + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +#[cfg(unix)] +async fn can_run_eth_node_with_auth_engine_api_over_ipc() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + let exec = TaskManager::current(); + let exec = exec.executor(); + + // Chain spec with test allocs + let genesis: Genesis = serde_json::from_str(include_str!("../assets/genesis.json")).unwrap(); + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(genesis) + .cancun_activated() + .build(), + ); + + // Node setup + let node_config = NodeConfig::test() + .with_chain(chain_spec) + .with_rpc(RpcServerArgs::default().with_unused_ports().with_http().with_auth_ipc()); + + let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config) + .testing_node(exec) + .node(EthereumNode::default()) + .launch() + .await?; + let mut node = NodeTestContext::new(node, eth_payload_attributes).await?; + + // Configure wallet from test mnemonic and create dummy transfer tx + let wallet = Wallet::default(); + let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).await; + + // make the node advance + let tx_hash = node.rpc.inject_tx(raw_tx).await?; + + // make the node advance + let payload = node.advance_block().await?; + + let block_hash = payload.block().hash(); + let block_number = payload.block().number; + + // assert the block has been committed to the blockchain + node.assert_new_block(tx_hash, block_hash, block_number).await?; + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +#[cfg(unix)] +async fn test_failed_run_eth_node_with_no_auth_engine_api_over_ipc_opts() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + let exec = TaskManager::current(); + let exec = exec.executor(); + + // Chain spec with test allocs + let genesis: Genesis = serde_json::from_str(include_str!("../assets/genesis.json")).unwrap(); + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(genesis) + .cancun_activated() + .build(), + ); + + // Node setup + let node_config = NodeConfig::test().with_chain(chain_spec); + let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config) + .testing_node(exec) + .node(EthereumNode::default()) + .launch() + .await?; + + let node = NodeTestContext::new(node, eth_payload_attributes).await?; + + // Ensure that the engine api client is not available + let client = node.inner.engine_ipc_client().await; + assert!(client.is_none(), "ipc auth should be disabled by default"); + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/fuzz.rs seismic-reth/crates/seismic/node/tests/e2e/fuzz.rs new file mode 100644 index 0000000000000000000000000000000000000000..5dcd963691ce86240bdbc476455adae0967a21bf --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/fuzz.rs @@ -0,0 +1,519 @@ +//! E2E fuzz tests for adversarial transaction handling. +//! +//! Spins up a dev node and bombards it with malformed, adversarial, and +//! signature-corrupted transactions across all tx types. Verifies the node +//! stays healthy after each batch. +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing, clippy::panic)] + +use alloy_consensus::TxEnvelope; +use alloy_eips::eip2718::Encodable2718; +use alloy_network::{EthereumWallet, TransactionBuilder}; +use alloy_primitives::{Address, Bytes, TxKind, B256, U256}; +use alloy_rpc_types::{Block, TransactionInput, TransactionRequest}; +use alloy_signer_local::PrivateKeySigner; +use core::str::FromStr; +use jsonrpsee::{core::client::ClientT, http_client::HttpClientBuilder, rpc_params}; +use rand::{rngs::SmallRng, Rng, SeedableRng}; +use reth_seismic_node::utils::{ + e2e::{ensure_mock_purpose_keys, setup}, + test_utils::{get_nonce, get_signed_seismic_tx_bytes}, +}; +use reth_seismic_rpc::ext::EthApiOverrideClient; +use tracing::{info, trace}; + +/// Number of random payloads per fuzz batch +const RANDOM_CASES: usize = 50; + +async fn get_recent_block_hash(client: &jsonrpsee::http_client::HttpClient) -> B256 { + let result: serde_json::Value = client + .request("eth_getBlockByNumber", rpc_params!["latest", false]) + .await + .expect("Failed to get latest block"); + let hash_str = result["hash"].as_str().expect("Block hash not found"); + B256::from_str(hash_str).expect("Failed to parse block hash") +} + +async fn assert_node_alive(client: &jsonrpsee::http_client::HttpClient, wallet_addr: Address) { + get_nonce(client, wallet_addr).await; +} + +/// Sends raw bytes to the node. Logs the outcome at trace level so accidental +/// acceptances are visible in CI logs when run with `--nocapture` or `RUST_LOG=trace`. +async fn send_raw(client: &jsonrpsee::http_client::HttpClient, raw: Bytes) { + match EthApiOverrideClient::<Block>::send_raw_transaction(client, raw.into()).await { + Ok(hash) => trace!(?hash, "tx accepted"), + Err(e) => trace!(%e, "tx rejected"), + } +} + +/// Sends raw bytes and asserts the node rejects them. Use for deterministic +/// hardcoded cases where acceptance would indicate a validation bug. +async fn assert_rejected(client: &jsonrpsee::http_client::HttpClient, raw: Bytes) { + assert!( + EthApiOverrideClient::<Block>::send_raw_transaction(client, raw.into()).await.is_err(), + "expected rejection for known-invalid payload" + ); +} + +/// Builds a signed EIP-1559 transaction with sensible defaults, then applies +/// field-level overrides so callers can target individual validation paths. +async fn build_signed_1559( + wallet: &EthereumWallet, + nonce: u64, + chain_id: u64, + overrides: TransactionRequest, +) -> Bytes { + let mut tx = TransactionRequest { + nonce: Some(nonce), + chain_id: Some(chain_id), + gas: Some(21_000), + max_fee_per_gas: Some(20_000_000_000u128), + max_priority_fee_per_gas: Some(1_000_000_000u128), + to: Some(TxKind::Call(Address::ZERO)), + value: Some(U256::ZERO), + input: TransactionInput::default(), + ..Default::default() + }; + + if overrides.gas.is_some() { + tx.gas = overrides.gas; + } + if overrides.max_fee_per_gas.is_some() { + tx.max_fee_per_gas = overrides.max_fee_per_gas; + } + if overrides.max_priority_fee_per_gas.is_some() { + tx.max_priority_fee_per_gas = overrides.max_priority_fee_per_gas; + } + if overrides.to.is_some() { + tx.to = overrides.to; + } + if overrides.value.is_some() { + tx.value = overrides.value; + } + if overrides.input.input.is_some() { + tx.input = overrides.input; + } + + let envelope = tx.build(wallet).await.expect("Failed to build tx"); + TxEnvelope::encoded_2718(&envelope).into() +} + +/// Replaces the last `n` bytes of `src` using a per-byte transform. +fn corrupt_last_n(src: &[u8], n: usize, f: impl Fn(u8) -> u8) -> Bytes { + let mut buf = src.to_vec(); + for b in buf.iter_mut().rev().take(n) { + *b = f(*b); + } + Bytes::from(buf) +} + +/// Replaces the last `n` bytes of `src` with random values. +fn corrupt_tail_random(src: &[u8], n: usize, rng: &mut impl Rng) -> Bytes { + let mut buf = src.to_vec(); + for b in buf.iter_mut().rev().take(n) { + *b = rng.random(); + } + Bytes::from(buf) +} + +// Sends hardcoded and randomly-generated malformed raw byte payloads. +// Exercises the RLP decoder and EIP-2718 type-prefix handling. +async fn send_malformed_raw_bytes( + client: &jsonrpsee::http_client::HttpClient, + addr: Address, + rng: &mut SmallRng, +) { + // empty payload + assert_rejected(client, Bytes::new()).await; + // bare EIP-4844 type prefix + assert_rejected(client, Bytes::from(vec![0x03])).await; + // bare seismic type prefix + assert_rejected(client, Bytes::from(vec![0x4A])).await; + // 1 KB of 0xFF + assert_rejected(client, Bytes::from(vec![0xFF; 1024])).await; + // truncated EIP-1559 RLP + assert_rejected(client, Bytes::from(vec![0x02, 0xF8, 0x50, 0x01])).await; + // truncated EIP-4844 RLP + assert_rejected(client, Bytes::from(vec![0x03, 0xF8, 0x50, 0x01, 0x02, 0x03])).await; + // truncated seismic RLP + assert_rejected(client, Bytes::from(vec![0x4A, 0xF8, 0x50, 0x01])).await; + // 256 sequential bytes (0x00..0xFF) + assert_rejected(client, Bytes::from((0u8..=255).collect::<Vec<u8>>())).await; + + let type_prefixes: &[u8] = &[0x00, 0x01, 0x02, 0x03, 0x04, 0x4A, 0x7F, 0x80, 0xFE, 0xFF]; + + for _ in 0..RANDOM_CASES { + let len = rng.random_range(1..4096); + let mut bytes: Vec<u8> = (0..len).map(|_| rng.random()).collect(); + // 50% chance of using a real type prefix + if rng.random_bool(0.5) { + bytes[0] = type_prefixes[rng.random_range(0..type_prefixes.len())]; + } + send_raw(client, Bytes::from(bytes)).await; + } + + assert_node_alive(client, addr).await; + info!("Node alive after malformed raw bytes (8 hardcoded + {RANDOM_CASES} random)"); +} + +// Sends hardcoded and randomly-generated adversarial EIP-1559 transactions. +// Tests validation of gas limits, fee parameters, value, and nonce bounds. +async fn send_adversarial_eip1559_txs( + client: &jsonrpsee::http_client::HttpClient, + eth_wallet: &EthereumWallet, + addr: Address, + chain_id: u64, + rng: &mut SmallRng, +) { + let nonce = get_nonce(client, addr).await; + + // gas_limit = 0 + assert_rejected( + client, + build_signed_1559( + eth_wallet, + nonce, + chain_id, + TransactionRequest { gas: Some(0), ..Default::default() }, + ) + .await, + ) + .await; + + // priority_fee > max_fee + assert_rejected( + client, + build_signed_1559( + eth_wallet, + nonce, + chain_id, + TransactionRequest { + max_fee_per_gas: Some(1_000), + max_priority_fee_per_gas: Some(1_000_000), + ..Default::default() + }, + ) + .await, + ) + .await; + + // value exceeds balance + assert_rejected( + client, + build_signed_1559( + eth_wallet, + nonce, + chain_id, + TransactionRequest { value: Some(U256::from(10u128.pow(30))), ..Default::default() }, + ) + .await, + ) + .await; + + // 128 KB input data (use u64::MAX nonce to ensure rejection — with valid gas + // and chain_id this would otherwise be a valid mempool tx) + assert_rejected( + client, + build_signed_1559( + eth_wallet, + u64::MAX, + chain_id, + TransactionRequest { + gas: Some(30_000_000), + input: TransactionInput { + input: Some(Bytes::from(vec![0xDE; 128_000])), + data: None, + }, + ..Default::default() + }, + ) + .await, + ) + .await; + + // nonce = u64::MAX + assert_rejected( + client, + build_signed_1559(eth_wallet, u64::MAX, chain_id, Default::default()).await, + ) + .await; + + // wrong chain_id + assert_rejected(client, build_signed_1559(eth_wallet, nonce, 999999, Default::default()).await) + .await; + + for _ in 0..RANDOM_CASES { + let overrides = TransactionRequest { + gas: Some(rng.random_range(0..30_000_000)), + max_fee_per_gas: Some(rng.random_range(0..u128::from(u64::MAX))), + max_priority_fee_per_gas: Some(rng.random_range(0..u128::from(u64::MAX))), + value: Some(U256::from(rng.random::<u128>())), + input: TransactionInput { + input: Some(Bytes::from( + (0..rng.random_range(0..1024)).map(|_| rng.random::<u8>()).collect::<Vec<u8>>(), + )), + data: None, + }, + ..Default::default() + }; + send_raw(client, build_signed_1559(eth_wallet, rng.random(), chain_id, overrides).await) + .await; + } + + assert_node_alive(client, addr).await; + info!("Node alive after adversarial EIP-1559 txs (6 hardcoded + {RANDOM_CASES} random)"); +} + +// Sends hardcoded and randomly-generated adversarial seismic transactions. +// Tests encryption metadata, block-hash validation, and calldata handling. +// +// TODO: add cases that corrupt seismic-specific fields (encryption_pubkey, +// encryption_nonce) post-encoding, similar to the signature corruption approach. +async fn send_adversarial_seismic_txs( + client: &jsonrpsee::http_client::HttpClient, + signer: &PrivateKeySigner, + addr: Address, + chain_id: u64, + rng: &mut SmallRng, +) { + let nonce = get_nonce(client, addr).await; + let recent_block_hash = get_recent_block_hash(client).await; + + // zero block hash + assert_rejected( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0x01]), + B256::ZERO, + ) + .await, + ) + .await; + + // random block hash + assert_rejected( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0x01]), + B256::from([0xFF; 32]), + ) + .await, + ) + .await; + + // nonce = u64::MAX + assert_rejected( + client, + get_signed_seismic_tx_bytes( + signer, + u64::MAX, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0x01]), + recent_block_hash, + ) + .await, + ) + .await; + + // wrong chain_id + assert_rejected( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + 999999, + Bytes::from(vec![0x01]), + recent_block_hash, + ) + .await, + ) + .await; + + // garbage calldata + send_raw( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0xDE, 0xAD, 0xBE, 0xEF]), + recent_block_hash, + ) + .await, + ) + .await; + + // contract creation + send_raw( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Create, + chain_id, + Bytes::from(vec![0x60, 0x00, 0x60, 0x00, 0xF3]), + recent_block_hash, + ) + .await, + ) + .await; + + // empty calldata + send_raw( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::new(), + recent_block_hash, + ) + .await, + ) + .await; + + // 64 KB calldata + send_raw( + client, + get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0xAB; 64_000]), + recent_block_hash, + ) + .await, + ) + .await; + + for _ in 0..RANDOM_CASES { + let calldata_len = rng.random_range(0..4096); + let calldata = + Bytes::from((0..calldata_len).map(|_| rng.random::<u8>()).collect::<Vec<u8>>()); + + let block_hash = match rng.random_range(0..3) { + 0 => recent_block_hash, + 1 => B256::ZERO, + _ => B256::from(rng.random::<[u8; 32]>()), + }; + + let to = if rng.random_bool(0.2) { + TxKind::Create + } else { + TxKind::Call(Address::from(rng.random::<[u8; 20]>())) + }; + + send_raw( + client, + get_signed_seismic_tx_bytes(signer, rng.random(), to, chain_id, calldata, block_hash) + .await, + ) + .await; + } + + assert_node_alive(client, addr).await; + info!("Node alive after adversarial seismic txs (8 hardcoded + {RANDOM_CASES} random)"); +} + +// Builds valid signed transactions, then corrupts parts of their signatures. +// Tests ecrecover / signer-recovery resilience for both EIP-1559 and seismic txs. +async fn send_signature_corrupted_txs( + client: &jsonrpsee::http_client::HttpClient, + eth_wallet: &EthereumWallet, + signer: &PrivateKeySigner, + addr: Address, + chain_id: u64, + rng: &mut SmallRng, +) { + let nonce = get_nonce(client, addr).await; + let recent_block_hash = get_recent_block_hash(client).await; + + let valid_bytes = + build_signed_1559(eth_wallet, nonce, chain_id, Default::default()).await.to_vec(); + + // corrupt last byte (part of signature s value) + send_raw(client, corrupt_last_n(&valid_bytes, 1, |b| b ^ 0xFF)).await; + // randomize entire s value + send_raw(client, corrupt_tail_random(&valid_bytes, 32, rng)).await; + // randomize entire r + s + send_raw(client, corrupt_tail_random(&valid_bytes, 64, rng)).await; + // zero out the entire signature + send_raw(client, corrupt_last_n(&valid_bytes, 65, |_| 0x00)).await; + // all-0xFF signature + send_raw(client, corrupt_last_n(&valid_bytes, 65, |_| 0xFF)).await; + + let seismic_bytes = get_signed_seismic_tx_bytes( + signer, + nonce, + TxKind::Call(Address::ZERO), + chain_id, + Bytes::from(vec![0x01]), + recent_block_hash, + ) + .await + .to_vec(); + + // corrupt last byte of seismic tx signature + send_raw(client, corrupt_last_n(&seismic_bytes, 1, |b| b ^ 0xFF)).await; + // randomize seismic r + s + send_raw(client, corrupt_tail_random(&seismic_bytes, 64, rng)).await; + + // random single-byte signature corruption across many txs + for _ in 0..RANDOM_CASES { + let raw = build_signed_1559(eth_wallet, rng.random(), chain_id, Default::default()).await; + let mut bytes = raw.to_vec(); + let len = bytes.len(); + let offset = rng.random_range(len.saturating_sub(65)..len); + bytes[offset] = rng.random(); + send_raw(client, Bytes::from(bytes)).await; + } + + assert_node_alive(client, addr).await; + info!("Node alive after signature-corrupted txs (7 hardcoded + {RANDOM_CASES} random)"); +} + +#[tokio::test(flavor = "multi_thread")] +async fn fuzz_adversarial_transactions() { + reth_tracing::init_test_tracing(); + ensure_mock_purpose_keys(); + + let (mut nodes, _tasks, wallet) = + tokio::spawn(setup(1)).await.expect("node setup task panicked").expect("setup failed"); + let mut node = nodes.pop().unwrap(); + let rpc_url = node.rpc_url().to_string(); + let chain_id = wallet.chain_id; + let client = HttpClientBuilder::default().build(&rpc_url).unwrap(); + + // Advance one block so that `get_recent_block_hash` returns a real hash + // for seismic tx tests that require a valid recent block hash. + node.advance_block().await.expect("failed to advance initial block"); + + let seed: u64 = + std::env::var("FUZZ_SEED").ok().and_then(|s| s.parse().ok()).unwrap_or_else(rand::random); + info!(%seed, "RNG seed — re-run with FUZZ_SEED={seed} to reproduce"); + let mut rng = SmallRng::seed_from_u64(seed); + + let eth_wallet: EthereumWallet = wallet.inner.clone().into(); + let addr = wallet.inner.address(); + + send_malformed_raw_bytes(&client, addr, &mut rng).await; + send_adversarial_eip1559_txs(&client, &eth_wallet, addr, chain_id, &mut rng).await; + send_adversarial_seismic_txs(&client, &wallet.inner, addr, chain_id, &mut rng).await; + send_signature_corrupted_txs(&client, &eth_wallet, &wallet.inner, addr, chain_id, &mut rng) + .await; + + info!("All batches passed — node remained healthy throughout"); +}

diff --git reth/crates/seismic/node/tests/e2e/hardfork_config.rs seismic-reth/crates/seismic/node/tests/e2e/hardfork_config.rs new file mode 100644 index 0000000000000000000000000000000000000000..030c24f8168ccc1a722efaf9d12cf3760cddfb45 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/hardfork_config.rs @@ -0,0 +1,127 @@ +//! Tests that Seismic hardfork configuration (Mercury) is correctly reported via RPC. +//! +//! This is the Seismic equivalent of `test_eth_config` in `crates/ethereum/node/tests/e2e/rpc.rs`, +//! which was disabled with `#[ignore = "We disabled fork activations"]`. +//! +//! Instead of testing fork scheduling (past/current/next at different timestamps), we verify +//! that the Seismic chain spec with Mercury hardfork active at genesis is correctly reflected +//! in the `eth_config` RPC response. + +use alloy_eips::eip7910::EthConfig; +use alloy_primitives::{Address, B256}; +use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder}; +use alloy_rpc_types_engine::PayloadAttributes; +use alloy_rpc_types_eth::TransactionRequest; +use reth_chainspec::{EthChainSpec, Hardforks, Head}; +use reth_e2e_test_utils::setup; +use reth_payload_builder::EthPayloadBuilderAttributes; +use reth_seismic_chainspec::SEISMIC_DEV; +use reth_seismic_node::{node::SeismicNode, purpose_keys::init_purpose_keys}; +use seismic_enclave::{ + get_unsecure_sample_schnorrkel_keypair, get_unsecure_sample_secp256k1_pk, + get_unsecure_sample_secp256k1_sk, GetPurposeKeysResponse, +}; +use std::sync::Once; + +/// Ensure mock purpose keys are initialized exactly once per test binary. +static INIT_KEYS: Once = Once::new(); +fn ensure_mock_purpose_keys() { + INIT_KEYS.call_once(|| { + init_purpose_keys(GetPurposeKeysResponse { + tx_io_sk: get_unsecure_sample_secp256k1_sk(), + tx_io_pk: get_unsecure_sample_secp256k1_pk(), + snapshot_key_bytes: [0u8; 32], + rng_keypair: get_unsecure_sample_schnorrkel_keypair(), + }); + }); +} + +/// Helper function to create a new eth payload attributes +fn eth_payload_attributes(timestamp: u64) -> EthPayloadBuilderAttributes { + let attributes = PayloadAttributes { + timestamp, + prev_randao: B256::ZERO, + suggested_fee_recipient: Address::ZERO, + withdrawals: Some(vec![]), + parent_beacon_block_root: Some(B256::ZERO), + }; + EthPayloadBuilderAttributes::new(B256::ZERO, attributes) +} + +/// Validates that the Mercury hardfork is correctly configured and reported via `eth_config` RPC. +/// +/// This test: +/// 1. Starts a Seismic node with the dev chain spec (all forks including Mercury at timestamp 0) +/// 2. Advances a block so the node has chain state +/// 3. Calls `eth_config` RPC ([EIP-7910](https://eips.ethereum.org/EIPS/eip-7910)) and verifies the +/// response +/// 4. Asserts that the current fork `activation_time` is 0 (Mercury active at genesis) +/// 5. Asserts that the `chain_id` matches the Seismic dev chain +/// 6. Asserts there is no next fork scheduled +#[tokio::test(flavor = "multi_thread")] +async fn test_mercury_hardfork_config() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + ensure_mock_purpose_keys(); + + let chain_spec = SEISMIC_DEV.clone(); + + let (mut nodes, _tasks, wallet) = + setup::<SeismicNode>(1, chain_spec.clone(), false, eth_payload_attributes).await?; + let mut node = nodes.pop().unwrap(); + let provider = ProviderBuilder::new() + .wallet(EthereumWallet::new(wallet.wallet_gen().swap_remove(0))) + .connect_http(node.rpc_url()); + + // Send a transaction and advance a block so the node has chain state beyond genesis + let _ = provider.send_transaction(TransactionRequest::default().to(Address::ZERO)).await?; + node.advance_block().await?; + + // Get the latest block timestamp for fork_id verification + let latest_block = provider.get_block_number().await?; + let latest_timestamp = provider + .get_block_by_number(latest_block.into()) + .await? + .expect("latest block should exist") + .header + .timestamp; + + // Query the eth_config RPC endpoint (EIP-7910) + let config: EthConfig = provider.client().request_noparams::<EthConfig>("eth_config").await?; + + // All Seismic forks (including Mercury) are activated at timestamp 0, so the current fork + // should have activation_time = 0. + assert_eq!( + config.current.activation_time, 0, + "Mercury hardfork should be active at timestamp 0" + ); + + // The chain_id in the config should match the Seismic dev chain id + assert_eq!( + config.current.chain_id, + chain_spec.chain().id(), + "chain_id should match Seismic dev chain" + ); + + // The fork_id should be non-empty and match the Seismic dev chain's fork hash, + // which is derived from the genesis hash and all fork block/timestamp activations. + // This is a stronger check than just activation_time — it proves the full fork + // schedule is Seismic-specific. + assert!(!config.current.fork_id.is_empty(), "fork_id should be set"); + + // Verify the fork_id matches what we compute from the chain spec directly. + // The fork_id is derived from genesis hash + all fork activations, so this proves + // the node is running with the correct Seismic fork schedule. + let fork_id = chain_spec.fork_id(&Head { timestamp: latest_timestamp, ..Default::default() }); + let expected_fork_hash = fork_id.hash.0; + let reported_fork_hash = config.current.fork_id.get(..4); + assert_eq!( + reported_fork_hash, + Some(expected_fork_hash.as_slice()), + "fork_id should match the Seismic dev chain fork hash" + ); + + // Since all forks are at timestamp 0, there should be no next fork scheduled + assert!(config.next.is_none(), "no next fork should be scheduled"); + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/integration.rs seismic-reth/crates/seismic/node/tests/e2e/integration.rs new file mode 100644 index 0000000000000000000000000000000000000000..9af4db9b1f3f99bcb17f5443d8eb86a2688b4cc1 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/integration.rs @@ -0,0 +1,1117 @@ +//! Integration tests for the Seismic node RPC. +//! +//! Each test spawns its own in-process Seismic node via `setup(1)`, eliminating +//! the previous subprocess-based approach (`cargo run --bin seismic-reth`). +//! Blocks are produced explicitly via `node.advance_block()` instead of relying +//! on dev-mode auto-mining with `thread::sleep`. +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing, clippy::panic)] // Test file - panics are acceptable + +use alloy_consensus::TxEnvelope; +use alloy_dyn_abi::EventExt; +use alloy_eips::eip2718::Encodable2718; +use alloy_json_abi::{Event, EventParam}; +use alloy_network::{EthereumWallet, ReceiptResponse, TransactionBuilder}; +use alloy_primitives::{ + aliases::{B96, U96}, + hex, + hex::FromHex, + Address, Bytes, IntoLogData, TxKind, B256, U256, +}; +use alloy_provider::{Provider, SendableTx}; +use alloy_rpc_types::{ + state::{AccountOverride, StateOverride}, + Block, Header, TransactionInput, TransactionRequest, +}; +use alloy_sol_types::{sol, SolCall, SolValue}; +use core::str::FromStr; +use jsonrpsee::{core::client::ClientT, http_client::HttpClientBuilder, rpc_params}; +use reth_e2e_test_utils::wallet::Wallet; +use reth_rpc_eth_api::EthApiClient; +use reth_seismic_node::utils::{ + e2e::{ensure_mock_purpose_keys, setup, SeismicTestNode}, + test_utils::{ + client_decrypt, get_nonce, get_seismic_metadata, get_signed_seismic_tx_bytes, + get_signed_seismic_tx_typed_data, get_unsigned_seismic_tx_request, + }, +}; +use reth_seismic_primitives::{ + test_utils::get_unsigned_legacy_tx_request, SeismicBlock, SeismicTransactionSigned, +}; +use reth_seismic_rpc::ext::EthApiOverrideClient; +use seismic_alloy_network::{ + reth::builder::seismic_reth_tx_builder, wallet::SeismicWallet, SeismicReth, +}; +use seismic_alloy_provider::{ + test_utils::ContractTestContext, SeismicProviderBuilder, SignedProviderExt, +}; +use seismic_alloy_rpc_types::{ + SeismicCallRequest, SeismicTransactionReceipt, SeismicTransactionRequest, SimBlock, + SimulatePayload, +}; +use seismic_enclave::aes_decrypt; + +const PRECOMPILES_TEST_SET_AES_KEY_SELECTOR: &str = "a0619040"; // setAESKey(suint256) +const PRECOMPILES_TEST_ENCRYPTED_LOG_SELECTOR: &str = "28696e36"; // submitMessage(bytes) + +/// Helper function to get a recent block hash from the client +async fn get_recent_block_hash(client: &jsonrpsee::http_client::HttpClient) -> B256 { + let result: serde_json::Value = client + .request("eth_getBlockByNumber", rpc_params!["latest", false]) + .await + .expect("Failed to get latest block"); + + let hash_str = result["hash"].as_str().expect("Block hash not found in response"); + + B256::from_str(hash_str).expect("Failed to parse block hash") +} + +/// Helper function to create a regular (non-seismic) deployment transaction +async fn get_signed_deploy_tx_bytes( + wallet: impl Into<EthereumWallet> + Clone, + nonce: u64, + chain_id: u64, + deploy_bytecode: Bytes, +) -> Bytes { + let tx = TransactionRequest { + from: None, + to: Some(TxKind::Create), + gas: Some(6000000), + max_fee_per_gas: Some(20e9 as u128), + max_priority_fee_per_gas: Some(1e9 as u128), + value: Some(U256::ZERO), + input: TransactionInput { input: Some(deploy_bytecode), data: None }, + nonce: Some(nonce), + chain_id: Some(chain_id), + ..Default::default() + }; + + let eth_wallet: EthereumWallet = wallet.into(); + let tx_envelope = tx.build(&eth_wallet).await.expect("Failed to build transaction"); + + TxEnvelope::encoded_2718(&tx_envelope).into() +} + +/// Sets up a single in-process Seismic node for testing and returns the node, +/// an HTTP RPC client, `chain_id`, wallet, and task manager. +/// +/// The `TaskManager` must be held alive for the test duration — dropping it +/// cancels background tasks that power the node. +async fn setup_test_node() -> eyre::Result<( + SeismicTestNode, + jsonrpsee::http_client::HttpClient, + u64, + Wallet, + reth_tasks::TaskManager, +)> { + reth_tracing::init_test_tracing(); + ensure_mock_purpose_keys(); + // Spawn node setup on a separate task to move the large async state machine + // (node + engine + RPC + EVM) onto the heap, avoiding stack overflow on + // x86_64 CI where stack frames are larger than on ARM64. + let (mut nodes, tasks, wallet) = + tokio::spawn(setup(1)).await.expect("node setup task panicked")?; + let node = nodes.pop().unwrap(); + let rpc_url = node.rpc_url().to_string(); + let chain_id = wallet.chain_id; + let client = HttpClientBuilder::default().build(&rpc_url)?; + Ok((node, client, chain_id, wallet, tasks)) +} + +/// Deploy contract, verify receipt and code, then return the contract address + block hash. +async fn rpc_test_deploy_contract( + node: &mut SeismicTestNode, + client: &jsonrpsee::http_client::HttpClient, + chain_id: u64, + wallet: &Wallet, +) -> eyre::Result<(alloy_primitives::Address, B256)> { + let tx_hash = EthApiOverrideClient::<Block>::send_raw_transaction( + client, + get_signed_deploy_tx_bytes( + wallet.inner.clone(), + get_nonce(client, wallet.inner.address()).await, + chain_id, + ContractTestContext::get_deploy_input_plaintext(), + ) + .await + .into(), + ) + .await + .unwrap(); + node.advance_block().await?; + + let receipt = EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::transaction_receipt(client, tx_hash) + .await + .unwrap() + .unwrap(); + let contract_addr = receipt.contract_address.unwrap(); + assert!(receipt.status()); + + let code = EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::get_code(client, contract_addr, None) + .await + .unwrap(); + assert_eq!(ContractTestContext::get_code(), code); + + let recent_block_hash = get_recent_block_hash(client).await; + Ok((contract_addr, recent_block_hash)) +} + +/// Verify parity via encrypted `eth_call`, returning the decrypted result as `U256`. +async fn rpc_test_check_parity( + client: &jsonrpsee::http_client::HttpClient, + chain_id: u64, + wallet: &Wallet, + contract_addr: alloy_primitives::Address, + recent_block_hash: B256, +) -> eyre::Result<U256> { + let nonce = get_nonce(client, wallet.inner.address()).await; + let to = TxKind::Call(contract_addr); + let output = EthApiOverrideClient::<Block>::call( + client, + get_signed_seismic_tx_bytes( + &wallet.inner, + nonce, + to, + chain_id, + ContractTestContext::get_is_odd_input_plaintext(), + recent_block_hash, + ) + .await + .into(), + None, + None, + None, + ) + .await + .unwrap(); + let metadata = get_seismic_metadata( + wallet.inner.address(), + chain_id, + nonce, + to, + U256::ZERO, + recent_block_hash, + ); + let decrypted = client_decrypt(metadata, &output).unwrap(); + Ok(U256::from_be_slice(&decrypted)) +} + +/// Send `set_number` transaction and advance block. +async fn rpc_test_set_number( + node: &mut SeismicTestNode, + client: &jsonrpsee::http_client::HttpClient, + chain_id: u64, + wallet: &Wallet, + contract_addr: alloy_primitives::Address, + recent_block_hash: B256, +) -> eyre::Result<()> { + let tx_hash = EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::send_raw_transaction( + client, + get_signed_seismic_tx_bytes( + &wallet.inner, + get_nonce(client, wallet.inner.address()).await, + TxKind::Call(contract_addr), + chain_id, + ContractTestContext::get_set_number_input_plaintext(), + recent_block_hash, + ) + .await, + ) + .await + .unwrap(); + node.advance_block().await?; + + let receipt = EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::transaction_receipt(client, tx_hash) + .await + .unwrap() + .unwrap(); + assert!(receipt.status()); + Ok(()) +} + +/// Test estimateGas, createAccessList, legacy call, and no-type call. +async fn rpc_test_gas_and_call_variants( + client: &jsonrpsee::http_client::HttpClient, + chain_id: u64, + wallet: &Wallet, + contract_addr: alloy_primitives::Address, + recent_block_hash: B256, +) -> eyre::Result<()> { + let simulate_tx_request = get_unsigned_seismic_tx_request( + &wallet.inner, + get_nonce(client, wallet.inner.address()).await, + TxKind::Call(contract_addr), + chain_id, + ContractTestContext::get_is_odd_input_plaintext(), + recent_block_hash, + ) + .await; + + // test eth_estimateGas with signed bytes (unsigned requests have `from` sanitized) + let gas = EthApiOverrideClient::<Block>::estimate_gas( + client, + get_signed_seismic_tx_bytes( + &wallet.inner, + get_nonce(client, wallet.inner.address()).await, + TxKind::Call(contract_addr), + chain_id, + ContractTestContext::get_is_odd_input_plaintext(), + recent_block_hash, + ) + .await + .into(), + None, + None, + ) + .await + .unwrap(); + assert!(gas > U256::ZERO); + + // test eth_estimateGas sanitizes unsigned seismic requests (clears `from` and + // seismic_elements to prevent caller spoofing, same as eth_call) + let unsigned_seismic_result = EthApiOverrideClient::<Block>::estimate_gas( + client, + SeismicCallRequest::TransactionRequest(simulate_tx_request.clone()), + None, + None, + ) + .await; + // Sanitized request simulates ciphertext as address(0) — expected to fail + assert!( + unsigned_seismic_result.is_err(), + "unsigned seismic estimateGas should fail after sanitization" + ); + + // test eth_estimateGas works for plain unsigned requests (standard Ethereum behavior) + let plain_unsigned_result = EthApiOverrideClient::<Block>::estimate_gas( + client, + SeismicCallRequest::TransactionRequest(SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(contract_addr)), + input: TransactionInput { + data: Some(ContractTestContext::get_is_odd_input_plaintext()), + ..Default::default() + }, + ..Default::default() + }, + seismic_elements: None, + }), + None, + None, + ) + .await + .unwrap(); + println!("eth_estimateGas for plain unsigned is_odd() gas: {:?}", plain_unsigned_result); + assert!(plain_unsigned_result > U256::ZERO); + + // TODO: should remove this functionality from seismic tx (audit) + let _access_list = + EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::create_access_list(client, simulate_tx_request.inner.clone().into(), None, None) + .await + .unwrap(); + + let is_odd_tx_request = get_unsigned_legacy_tx_request( + &wallet.inner, + get_nonce(client, wallet.inner.address()).await, + TxKind::Call(contract_addr), + chain_id, + ContractTestContext::get_is_odd_input_plaintext(), + ) + .await; + + let _output = EthApiOverrideClient::<Block>::call( + client, + is_odd_tx_request.clone().into(), + None, + None, + None, + ) + .await + .unwrap(); + + // call with no transaction type + let _output = EthApiOverrideClient::<Block>::call( + client, + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + input: TransactionInput { + data: Some(ContractTestContext::get_is_odd_input_plaintext()), + ..Default::default() + }, + to: Some(TxKind::Call(contract_addr)), + ..Default::default() + }, + seismic_elements: None, + } + .into(), + None, + None, + None, + ) + .await + .unwrap(); + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_reth_rpc() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let (contract_addr, recent_block_hash) = + rpc_test_deploy_contract(&mut node, &client, chain_id, &wallet).await?; + + // parity should be 0 before set_number + let parity = + rpc_test_check_parity(&client, chain_id, &wallet, contract_addr, recent_block_hash).await?; + assert_eq!(parity, U256::ZERO); + + rpc_test_set_number(&mut node, &client, chain_id, &wallet, contract_addr, recent_block_hash) + .await?; + + // parity should be 1 after set_number + let parity = + rpc_test_check_parity(&client, chain_id, &wallet, contract_addr, recent_block_hash).await?; + assert_eq!(parity, U256::from(1)); + + rpc_test_gas_and_call_variants(&client, chain_id, &wallet, contract_addr, recent_block_hash) + .await?; + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_reth_rpc_with_typed_data() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let (contract_addr, recent_block_hash) = + rpc_test_deploy_contract(&mut node, &client, chain_id, &wallet).await?; + + let nonce = get_nonce(&client, wallet.inner.address()).await; + let to = TxKind::Call(contract_addr); + let output = EthApiOverrideClient::<Block>::call( + &client, + get_signed_seismic_tx_typed_data( + &wallet.inner, + nonce, + to, + chain_id, + ContractTestContext::get_is_odd_input_plaintext(), + recent_block_hash, + ) + .await + .into(), + None, + None, + None, + ) + .await + .unwrap(); + let metadata = get_seismic_metadata( + wallet.inner.address(), + chain_id, + nonce, + to, + U256::ZERO, + recent_block_hash, + ); + let decrypted_output = client_decrypt(metadata, &output).unwrap(); + assert_eq!(U256::from_be_slice(&decrypted_output), U256::ZERO); + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_reth_rpc_with_rust_client() -> eyre::Result<()> { + let (mut node, _client, chain_id, _wallet, _tasks) = setup_test_node().await?; + let reth_rpc_url = node.rpc_url().to_string(); + + let _wallet = Wallet::default().with_chain_id(chain_id); + let wallet: SeismicWallet<SeismicReth> = SeismicWallet::from(_wallet.inner); + + let provider = SeismicProviderBuilder::new() + .wallet(wallet) + .connect_http(reqwest::Url::parse(&reth_rpc_url).unwrap()) + .await + .unwrap(); + + let req = TransactionBuilder::<SeismicReth>::with_kind( + TransactionBuilder::<SeismicReth>::with_input( + SeismicTransactionRequest::default(), + ContractTestContext::get_deploy_input_plaintext(), + ), + TxKind::Create, + ); + let pending_transaction = provider.send_transaction(req).await.unwrap(); + let tx_hash = *pending_transaction.tx_hash(); + node.advance_block().await?; + + let receipt = provider.get_transaction_receipt(tx_hash).await.unwrap().unwrap(); + let contract_addr = receipt.contract_address.unwrap(); + assert!(receipt.status()); + + let code = provider.get_code_at(contract_addr).await.unwrap(); + assert_eq!(ContractTestContext::get_code(), code); + + let output = provider + .seismic_call_raw(SendableTx::Builder(TransactionBuilder::<SeismicReth>::with_to( + TransactionBuilder::<SeismicReth>::with_input( + SeismicTransactionRequest::default(), + ContractTestContext::get_is_odd_input_plaintext(), + ), + contract_addr, + ))) + .await + .unwrap(); + assert_eq!(U256::from_be_slice(&output), U256::ZERO); + + let set_num_tx = seismic_reth_tx_builder() + .with_input(ContractTestContext::get_set_number_input_plaintext()) + .with_to(contract_addr) + .into(); + let pending_transaction = provider.send_transaction(set_num_tx).await.unwrap(); + let tx_hash = *pending_transaction.tx_hash(); + node.advance_block().await?; + + let receipt = provider.get_transaction_receipt(tx_hash).await.unwrap().unwrap(); + assert!(receipt.status()); + + let output = provider + .seismic_call_raw(SendableTx::Builder(TransactionBuilder::<SeismicReth>::with_to( + TransactionBuilder::<SeismicReth>::with_input( + SeismicTransactionRequest::default(), + ContractTestContext::get_is_odd_input_plaintext(), + ), + contract_addr, + ))) + .await + .unwrap(); + assert_eq!(U256::from_be_slice(&output), U256::from(1)); + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_precompiles_end_to_end() -> eyre::Result<()> { + let (mut node, _client, chain_id, _wallet, _tasks) = setup_test_node().await?; + let reth_rpc_url = node.rpc_url().to_string(); + + let _wallet = Wallet::default().with_chain_id(chain_id); + let from = _wallet.inner.address(); + let wallet: SeismicWallet<SeismicReth> = SeismicWallet::from(_wallet.inner); + + let provider = SeismicProviderBuilder::new() + .wallet(wallet) + .connect_http(reqwest::Url::parse(&reth_rpc_url).unwrap()) + .await + .unwrap(); + let req = TransactionBuilder::<SeismicReth>::with_kind( + TransactionBuilder::<SeismicReth>::with_input( + SeismicTransactionRequest::default(), + get_encryption_precompiles_contracts(), + ), + TxKind::Create, + ); + let pending_transaction = provider.send_transaction(req).await.unwrap(); + let tx_hash = *pending_transaction.tx_hash(); + node.advance_block().await?; + + let receipt = provider.get_transaction_receipt(tx_hash).await.unwrap().unwrap(); + let contract_addr = receipt.contract_address.unwrap(); + assert!(receipt.status()); + + let code = provider.get_code_at(contract_addr).await.unwrap(); + assert!(!code.is_empty(), "contract should have runtime code after deployment"); + + let private_key = + B256::from_hex("7e34abdcd62eade2e803e0a8123a0015ce542b380537eff288d6da420bcc2d3b").unwrap(); + + // Tx #1: Set AES key in the contract + let unencrypted_aes_key = get_input_data(PRECOMPILES_TEST_SET_AES_KEY_SELECTOR, private_key); + let pending = provider + .send_transaction( + seismic_reth_tx_builder() + .with_from(from) + .with_to(contract_addr) + .with_input(unencrypted_aes_key) + .into(), + ) + .await + .unwrap(); + let set_key_tx_hash = *pending.tx_hash(); + node.advance_block().await?; + let receipt = provider.get_transaction_receipt(set_key_tx_hash).await.unwrap().unwrap(); + assert!(receipt.status()); + + // Tx #2: Encrypt & send "hello world" + let raw_message = "hello world"; + let message = Bytes::from(raw_message); + type PlaintextType = Bytes; + + let encoded_message = PlaintextType::abi_encode(&message); + let unencrypted_input = + concat_input_data(PRECOMPILES_TEST_ENCRYPTED_LOG_SELECTOR, encoded_message.into()); + + let pending = provider + .send_transaction( + seismic_reth_tx_builder() + .with_from(from) + .with_to(contract_addr) + .with_input(unencrypted_input) + .into(), + ) + .await + .unwrap(); + let encrypt_tx_hash = *pending.tx_hash(); + node.advance_block().await?; + let receipt = provider.get_transaction_receipt(encrypt_tx_hash).await.unwrap().unwrap(); + + // Verify the encrypted log event + let logs = receipt.inner.logs(); + assert_eq!(logs.len(), 1); + assert_eq!(logs[0].inner.address, contract_addr); + + let log_data = logs[0].inner.data.clone(); + let event = Event { + name: "EncryptedMessage".into(), + inputs: vec![ + EventParam { ty: "uint96".into(), indexed: true, ..Default::default() }, + EventParam { ty: "bytes".into(), indexed: false, ..Default::default() }, + ], + anonymous: false, + }; + let decoded = event.decode_log(&log_data.into_log_data()).unwrap(); + + sol! { + #[derive(Debug, PartialEq, Eq)] + interface Encryption { + function decrypt(uint96 nonce, bytes calldata ciphertext) + external + view + onlyOwner + returns (bytes memory plaintext); + } + } + + let nonce: U96 = + U96::from_be_bytes(B96::from_slice(&decoded.indexed[0].abi_encode_packed()).into()); + let ciphertext = Bytes::from(decoded.body[0].abi_encode_packed()); + + let call = Encryption::decryptCall { nonce, ciphertext: ciphertext.clone() }; + let unencrypted_decrypt_call = Bytes::from(call.abi_encode()); + + let tx_req = seismic_reth_tx_builder() + .with_from(from) + .with_to(contract_addr) + .with_input(unencrypted_decrypt_call) + .into() + .seismic(); + + let output = provider.seismic_call_raw(SendableTx::Builder(tx_req)).await.unwrap(); + + // Locally decrypt to cross-check + let secp_private = secp256k1::SecretKey::from_slice(private_key.as_ref()).unwrap(); + let aes_key: &[u8; 32] = &secp_private.secret_bytes()[0..32].try_into().unwrap(); + let nonce: [u8; 12] = decoded.indexed[0].abi_encode_packed().try_into().unwrap(); + let decrypted_locally = + aes_decrypt(aes_key.into(), &ciphertext, nonce).expect("AES decryption failed"); + assert_eq!(decrypted_locally, message); + + let result_bytes = PlaintextType::abi_decode(&output).expect("failed to decode the bytes"); + let final_string = + String::from_utf8(result_bytes.to_vec()).expect("invalid utf8 in decrypted bytes"); + assert_eq!(final_string, raw_message); + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_call_rejects_sload_on_private_storage() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let contract_addr = flagged_storage_deploy_and_write( + &mut node, + &client, + chain_id, + &wallet, + FLAGGED_STORAGE_SET_PRIVATE, + U256::from(42), + ) + .await?; + + // Raw SLOAD on private storage via eth_call - should FAIL + let read_calldata: Bytes = hex::decode(FLAGGED_STORAGE_READ_PRIVATE_SLOAD_RAW).unwrap().into(); + let result = EthApiOverrideClient::<Block>::call( + &client, + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(contract_addr)), + input: TransactionInput { data: Some(read_calldata), ..Default::default() }, + ..Default::default() + }, + seismic_elements: None, + } + .into(), + None, + None, + None, + ) + .await; + + match &result { + Ok(output) => panic!("SLOAD on private storage should fail, but got Ok: {:?}", output), + Err(e) => { + let err_msg = e.to_string().to_lowercase(); + assert!( + err_msg.contains("invalidprivatestorageaccess"), + "Expected 'InvalidPrivateStorageAccess' revert, got: {}", + err_msg + ); + } + } + + Ok(()) +} + +/// Deploy flagged storage contract and write a value, returning contract address. +async fn flagged_storage_deploy_and_write( + node: &mut SeismicTestNode, + client: &jsonrpsee::http_client::HttpClient, + chain_id: u64, + wallet: &Wallet, + selector: &str, + value: U256, +) -> eyre::Result<alloy_primitives::Address> { + let tx_hash = EthApiOverrideClient::<Block>::send_raw_transaction( + client, + get_signed_deploy_tx_bytes( + wallet.inner.clone(), + get_nonce(client, wallet.inner.address()).await, + chain_id, + Bytes::from_static(FLAGGED_STORAGE_TEST_BYTECODE), + ) + .await + .into(), + ) + .await + .unwrap(); + node.advance_block().await?; + + let receipt = EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::transaction_receipt(client, tx_hash) + .await + .unwrap() + .unwrap(); + let contract_addr = receipt.contract_address.unwrap(); + assert!(receipt.status()); + + // Write value via seismic tx + let block_hash = get_recent_block_hash(client).await; + let set_data = get_input_data(selector, B256::from(value)); + EthApiClient::< + SeismicTransactionRequest, + SeismicTransactionSigned, + SeismicBlock, + SeismicTransactionReceipt, + Header, + >::send_raw_transaction( + client, + get_signed_seismic_tx_bytes( + &wallet.inner, + get_nonce(client, wallet.inner.address()).await, + TxKind::Call(contract_addr), + chain_id, + set_data, + block_hash, + ) + .await, + ) + .await + .unwrap(); + node.advance_block().await?; + + Ok(contract_addr) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_call_allows_cload_on_public_storage() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let contract_addr = flagged_storage_deploy_and_write( + &mut node, + &client, + chain_id, + &wallet, + FLAGGED_STORAGE_SET_PUBLIC, + U256::from(123), + ) + .await?; + + let block_hash = get_recent_block_hash(&client).await; + let read_calldata: Bytes = hex::decode(FLAGGED_STORAGE_READ_PUBLIC_CLOAD).unwrap().into(); + let nonce = get_nonce(&client, wallet.inner.address()).await; + let result = EthApiOverrideClient::<Block>::call( + &client, + get_signed_seismic_tx_bytes( + &wallet.inner, + nonce, + TxKind::Call(contract_addr), + chain_id, + read_calldata, + block_hash, + ) + .await + .into(), + None, + None, + None, + ) + .await; + + assert!(result.is_ok(), "CLOAD on public storage should succeed, got: {:?}", result.err()); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_call_allows_cload_on_private_storage() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let contract_addr = flagged_storage_deploy_and_write( + &mut node, + &client, + chain_id, + &wallet, + FLAGGED_STORAGE_SET_PRIVATE, + U256::from(42), + ) + .await?; + + let block_hash = get_recent_block_hash(&client).await; + let read_calldata: Bytes = hex::decode(FLAGGED_STORAGE_READ_PRIVATE_CLOAD).unwrap().into(); + let nonce = get_nonce(&client, wallet.inner.address()).await; + let to = TxKind::Call(contract_addr); + let output = EthApiOverrideClient::<Block>::call( + &client, + get_signed_seismic_tx_bytes(&wallet.inner, nonce, to, chain_id, read_calldata, block_hash) + .await + .into(), + None, + None, + None, + ) + .await + .expect("CLOAD on private storage should succeed"); + + let metadata = + get_seismic_metadata(wallet.inner.address(), chain_id, nonce, to, U256::ZERO, block_hash); + let decrypted = client_decrypt(metadata, &output).unwrap(); + assert_eq!(U256::from_be_slice(&decrypted), U256::from(42)); + Ok(()) +} + +/// Test that Solidity-level `readPublicSload()` succeeds. +/// (compiler uses regular SLOAD on public slot — should work) +#[tokio::test(flavor = "multi_thread")] +async fn test_solidity_read_public_sload_succeeds() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let contract_addr = flagged_storage_deploy_and_write( + &mut node, + &client, + chain_id, + &wallet, + FLAGGED_STORAGE_SET_PUBLIC, + U256::from(123), + ) + .await?; + + let read_calldata: Bytes = hex::decode(FLAGGED_STORAGE_READ_PUBLIC_SLOAD).unwrap().into(); + let result = EthApiOverrideClient::<Block>::call( + &client, + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(contract_addr)), + input: TransactionInput { data: Some(read_calldata), ..Default::default() }, + ..Default::default() + }, + seismic_elements: None, + } + .into(), + None, + None, + None, + ) + .await + .expect("Solidity readPublicSload() should succeed"); + + assert_eq!( + U256::from_be_slice(&result), + U256::from(123), + "readPublicSload() should return 123" + ); + Ok(()) +} + +/// Test that Solidity-level `readPrivateSload()` succeeds. +/// (compiler uses CLOAD internally for suint256 types, so this passes) +#[tokio::test(flavor = "multi_thread")] +async fn test_solidity_read_private_succeeds() -> eyre::Result<()> { + let (mut node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let contract_addr = flagged_storage_deploy_and_write( + &mut node, + &client, + chain_id, + &wallet, + FLAGGED_STORAGE_SET_PRIVATE, + U256::from(42), + ) + .await?; + + let read_calldata: Bytes = hex::decode(FLAGGED_STORAGE_READ_PRIVATE_SLOAD).unwrap().into(); + let result = EthApiOverrideClient::<Block>::call( + &client, + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(contract_addr)), + input: TransactionInput { data: Some(read_calldata), ..Default::default() }, + ..Default::default() + }, + seismic_elements: None, + } + .into(), + None, + None, + None, + ) + .await + .expect("Solidity readPrivateSload() should succeed (compiler uses CLOAD)"); + + assert_eq!(U256::from_be_slice(&result), U256::from(42), "readPrivateSload() should return 42"); + Ok(()) +} + +// FlaggedStorageTestContract bytecode and selectors +const FLAGGED_STORAGE_TEST_BYTECODE: &[u8] = &hex!("6080604052348015600e575f5ffd5b506103048061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610086575f3560e01c8063717d5de311610059578063717d5de3146100fe57806394193f111461011c5780639ad95ef81461013a578063ef5617921461015857610086565b806331845f7d1461008a578063420f38f8146100a65780634e0d898c146100c25780635d5b397f146100e0575b5f5ffd5b6100a4600480360381019061009f91906101f6565b610176565b005b6100c060048036038101906100bb9190610254565b61017f565b005b6100ca610189565b6040516100d7919061028e565b60405180910390f35b6100e8610192565b6040516100f5919061028e565b60405180910390f35b610106610197565b604051610113919061028e565b60405180910390f35b61012461019f565b604051610131919061028e565b60405180910390f35b6101426101aa565b60405161014f919061028e565b60405180910390f35b6101606101b6565b60405161016d919061028e565b60405180910390f35b805f8190555050565b8060018190b15050565b5f600154905090565b5f5481565b5f5f54905090565b5f5fb0805f5260205ff35b5f6001b0805f5260205ff35b5f6001b0905090565b5f5ffd5b5f819050919050565b6101d5816101c3565b81146101df575f5ffd5b50565b5f813590506101f0816101cc565b92915050565b5f6020828403121561020b5761020a6101bf565b5b5f610218848285016101e2565b91505092915050565b5f819050919050565b61023381610221565b811461023d575f5ffd5b50565b5f8135905061024e8161022a565b92915050565b5f60208284031215610269576102686101bf565b5b5f61027684828501610240565b91505092915050565b610288816101c3565b82525050565b5f6020820190506102a15f83018461027f565b9291505056fea2646970667358221220bed26217d42178260b773a5edf5b427f93dde38ce69f366f5ac8ace37b09e4fd64736f6c637829302e382e33312d646576656c6f702e323032352e31312e31322b636f6d6d69742e3637366264656363005a"); +const FLAGGED_STORAGE_SET_PUBLIC: &str = "31845f7d"; // setPublic(uint256) +const FLAGGED_STORAGE_SET_PRIVATE: &str = "420f38f8"; // setPrivate(suint256) +const FLAGGED_STORAGE_READ_PUBLIC_SLOAD: &str = "717d5de3"; // readPublicSload() +const FLAGGED_STORAGE_READ_PRIVATE_SLOAD: &str = "ef561792"; // readPrivateSload() +const FLAGGED_STORAGE_READ_PRIVATE_SLOAD_RAW: &str = "4e0d898c"; // readPrivateSloadRaw() +const FLAGGED_STORAGE_READ_PRIVATE_CLOAD: &str = "9ad95ef8"; // readPrivateCload() +const FLAGGED_STORAGE_READ_PUBLIC_CLOAD: &str = "94193f11"; // readPublicCload() + +const fn get_encryption_precompiles_contracts() -> Bytes { + Bytes::from_static(&hex!("6080604052348015600e575f5ffd5b50335f5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610dce8061005b5f395ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806328696e361461004e5780638da5cb5b1461006a578063a061904014610088578063ce75255b146100a4575b5f5ffd5b61006860048036038101906100639190610687565b6100d4565b005b61007261019a565b60405161007f9190610711565b60405180910390f35b6100a2600480360381019061009d919061075d565b6101be565b005b6100be60048036038101906100b991906107c9565b610256565b6040516100cb9190610896565b60405180910390f35b5f6100dd610412565b90505f61012d8285858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f820116905080830192505050505050506104f5565b9050816bffffffffffffffffffffffff167f093a34a48cc07b4bf1355d9c15ec71077c85342d872753188302f99341f961008260405160200161017091906108f0565b60405160208183030381529060405260405161018c9190610896565b60405180910390a250505050565b5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461024c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161024390610986565b60405180910390fd5b8060018190b15050565b60605f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146102e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016102dd90610986565b60405180910390fd5b5f838390501161032b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610322906109ee565b60405180910390fd5b5f606790505f6001b086868660405160200161034a9493929190610a92565b60405160208183030381529060405290505f5f8373ffffffffffffffffffffffffffffffffffffffff168360405161038291906108f0565b5f60405180830381855afa9150503d805f81146103ba576040519150601f19603f3d011682016040523d82523d5f602084013e6103bf565b606091505b509150915081610404576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103fb90610b3c565b60405180910390fd5b809450505050509392505050565b5f5f606490505f5f8273ffffffffffffffffffffffffffffffffffffffff1660206040516020016104439190610b9d565b60405160208183030381529060405260405161045f91906108f0565b5f60405180830381855afa9150503d805f8114610497576040519150601f19603f3d011682016040523d82523d5f602084013e61049c565b606091505b5091509150816104e1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104d890610c01565b60405180910390fd5b5f60208201519050805f1c94505050505090565b60605f606690505f6001b0858560405160200161051493929190610c1f565b60405160208183030381529060405290505f5f8373ffffffffffffffffffffffffffffffffffffffff168360405161054c91906108f0565b5f60405180830381855afa9150503d805f8114610584576040519150601f19603f3d011682016040523d82523d5f602084013e610589565b606091505b5091509150816105ce576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105c590610cc7565b60405180910390fd5b5f815111610611576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161060890610d55565b60405180910390fd5b8094505050505092915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f84011261064757610646610626565b5b8235905067ffffffffffffffff8111156106645761066361062a565b5b6020830191508360018202830111156106805761067f61062e565b5b9250929050565b5f5f6020838503121561069d5761069c61061e565b5b5f83013567ffffffffffffffff8111156106ba576106b9610622565b5b6106c685828601610632565b92509250509250929050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6106fb826106d2565b9050919050565b61070b816106f1565b82525050565b5f6020820190506107245f830184610702565b92915050565b5f819050919050565b61073c8161072a565b8114610746575f5ffd5b50565b5f8135905061075781610733565b92915050565b5f602082840312156107725761077161061e565b5b5f61077f84828501610749565b91505092915050565b5f6bffffffffffffffffffffffff82169050919050565b6107a881610788565b81146107b2575f5ffd5b50565b5f813590506107c38161079f565b92915050565b5f5f5f604084860312156107e0576107df61061e565b5b5f6107ed868287016107b5565b935050602084013567ffffffffffffffff81111561080e5761080d610622565b5b61081a86828701610632565b92509250509250925092565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f61086882610826565b6108728185610830565b9350610882818560208601610840565b61088b8161084e565b840191505092915050565b5f6020820190508181035f8301526108ae818461085e565b905092915050565b5f81905092915050565b5f6108ca82610826565b6108d481856108b6565b93506108e4818560208601610840565b80840191505092915050565b5f6108fb82846108c0565b915081905092915050565b5f82825260208201905092915050565b7f4f6e6c79206f776e65722063616e2063616c6c20746869732066756e6374696f5f8201527f6e00000000000000000000000000000000000000000000000000000000000000602082015250565b5f610970602183610906565b915061097b82610916565b604082019050919050565b5f6020820190508181035f83015261099d81610964565b9050919050565b7f436970686572746578742063616e6e6f7420626520656d7074790000000000005f82015250565b5f6109d8601a83610906565b91506109e3826109a4565b602082019050919050565b5f6020820190508181035f830152610a05816109cc565b9050919050565b5f819050919050565b610a26610a218261072a565b610a0c565b82525050565b5f8160a01b9050919050565b5f610a4282610a2c565b9050919050565b610a5a610a5582610788565b610a38565b82525050565b828183375f83830152505050565b5f610a7983856108b6565b9350610a86838584610a60565b82840190509392505050565b5f610a9d8287610a15565b602082019150610aad8286610a49565b600c82019150610abe828486610a6e565b915081905095945050505050565b7f414553206465637279707420707265636f6d70696c652063616c6c206661696c5f8201527f6564000000000000000000000000000000000000000000000000000000000000602082015250565b5f610b26602283610906565b9150610b3182610acc565b604082019050919050565b5f6020820190508181035f830152610b5381610b1a565b9050919050565b5f63ffffffff82169050919050565b5f8160e01b9050919050565b5f610b7f82610b69565b9050919050565b610b97610b9282610b5a565b610b75565b82525050565b5f610ba88284610b86565b60048201915081905092915050565b7f524e4720507265636f6d70696c652063616c6c206661696c65640000000000005f82015250565b5f610beb601a83610906565b9150610bf682610bb7565b602082019050919050565b5f6020820190508181035f830152610c1881610bdf565b9050919050565b5f610c2a8286610a15565b602082019150610c3a8285610a49565b600c82019150610c4a82846108c0565b9150819050949350505050565b7f41455320656e637279707420707265636f6d70696c652063616c6c206661696c5f8201527f6564000000000000000000000000000000000000000000000000000000000000602082015250565b5f610cb1602283610906565b9150610cbc82610c57565b604082019050919050565b5f6020820190508181035f830152610cde81610ca5565b9050919050565b7f456e6372797074696f6e2063616c6c2072657475726e6564206e6f206f7574705f8201527f7574000000000000000000000000000000000000000000000000000000000000602082015250565b5f610d3f602283610906565b9150610d4a82610ce5565b604082019050919050565b5f6020820190508181035f830152610d6c81610d33565b905091905056fea2646970667358221220cdc3edd7891930a1ad58becbe2b3f7679ecfc78a3b1f8a803d4c381c8318287864736f6c637827302e382e32382d63692e323032342e31312e342b636f6d6d69742e32306261666332392e6d6f640058")) +} + +fn get_input_data(selector: &str, value: B256) -> Bytes { + let selector_bytes: Vec<u8> = hex::decode(&selector[0..8]).expect("Invalid selector"); + let value_bytes: Bytes = value.into(); + let mut input_data = Vec::new(); + input_data.extend_from_slice(&selector_bytes); + input_data.extend_from_slice(&value_bytes); + input_data.into() +} + +fn concat_input_data(selector: &str, value: Bytes) -> Bytes { + let selector_bytes: Vec<u8> = hex::decode(&selector[0..8]).expect("Invalid selector"); + let value_bytes: Bytes = value; + let mut input_data = Vec::new(); + input_data.extend_from_slice(&selector_bytes); + input_data.extend_from_slice(&value_bytes); + input_data.into() +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_call_rejects_code_override() -> eyre::Result<()> { + let (_node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let victim_addr = Address::from_hex("0x0000000000000000000000000000000000001234").unwrap(); + + let mut state_overrides = StateOverride::default(); + state_overrides.insert( + victim_addr, + AccountOverride { + code: Some(Bytes::from_static(&hex!( + "7f0000000000000000000000000000000000000000000000000000000000000001b060005260206000f3" + ))), + ..Default::default() + }, + ); + + let result = EthApiOverrideClient::<Block>::call( + &client, + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(victim_addr)), + gas: Some(1_000_000), + chain_id: Some(chain_id), + ..Default::default() + }, + seismic_elements: None, + } + .into(), + None, + Some(state_overrides), + None, + ) + .await; + + match &result { + Ok(output) => panic!( + "eth_call with code override should be rejected, but got Ok: 0x{}", + hex::encode(output) + ), + Err(e) => { + let err_msg = e.to_string(); + assert!( + err_msg.to_lowercase().contains("code overrides are not permitted"), + "Expected code override rejection error, got: {}", + err_msg + ); + } + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_estimate_gas_rejects_code_override() -> eyre::Result<()> { + let (_node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let victim_addr = Address::from_hex("0x0000000000000000000000000000000000001234").unwrap(); + + let mut state_overrides = StateOverride::default(); + state_overrides.insert( + victim_addr, + AccountOverride { + code: Some(Bytes::from_static(&hex!("6001b060005260206000f3"))), + ..Default::default() + }, + ); + + let result = EthApiOverrideClient::<Block>::estimate_gas( + &client, + SeismicCallRequest::TransactionRequest(SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(wallet.inner.address()), + to: Some(TxKind::Call(victim_addr)), + gas: Some(1_000_000), + chain_id: Some(chain_id), + ..Default::default() + }, + seismic_elements: None, + }), + None, + Some(state_overrides), + ) + .await; + + match &result { + Ok(gas) => { + panic!("eth_estimateGas with code override should be rejected, but got Ok: {}", gas) + } + Err(e) => { + let err_msg = e.to_string(); + assert!( + err_msg.to_lowercase().contains("code overrides are not permitted"), + "Expected code override rejection error, got: {}", + err_msg + ); + } + } + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_eth_simulate_v1_rejects_code_override() -> eyre::Result<()> { + let (_node, client, chain_id, wallet, _tasks) = setup_test_node().await?; + + let victim_addr = Address::from_hex("0x0000000000000000000000000000000000001234").unwrap(); + + let mut state_overrides = StateOverride::default(); + state_overrides.insert( + victim_addr, + AccountOverride { + code: Some(Bytes::from_static(&hex!("6001b060005260206000f3"))), + ..Default::default() + }, + ); + + let nonce = get_nonce(&client, wallet.inner.address()).await; + let tx_bytes = get_signed_deploy_tx_bytes( + wallet.inner.clone(), + nonce, + chain_id, + ContractTestContext::get_deploy_input_plaintext(), + ) + .await; + + let block_with_code_override = SimBlock { + block_overrides: None, + state_overrides: Some(state_overrides), + calls: vec![SeismicCallRequest::Bytes(tx_bytes)], + }; + + let simulate_payload = SimulatePayload::<SeismicCallRequest> { + block_state_calls: vec![block_with_code_override], + trace_transfers: false, + validation: false, + return_full_transactions: false, + }; + + let result = EthApiOverrideClient::<Block>::simulate_v1(&client, simulate_payload, None).await; + + match &result { + Ok(_) => panic!("eth_simulateV1 with code override should be rejected"), + Err(e) => { + let err_msg = e.to_string(); + assert!( + err_msg.to_lowercase().contains("code overrides are not permitted"), + "Expected code override rejection error, got: {}", + err_msg + ); + } + } + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/main.rs seismic-reth/crates/seismic/node/tests/e2e/main.rs new file mode 100644 index 0000000000000000000000000000000000000000..8c9653854e36e422c160534b3f6454a970cf2c9c --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/main.rs @@ -0,0 +1,12 @@ +#![allow(missing_docs, clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)] + +mod fuzz; +mod hardfork_config; +mod integration; +mod ops; +mod p2p; +//mod rpc_compat; // todo: disabling for now we need a more sustainable way to generate state +// roots. Currently broken from stable coin gas update not burning gas +mod testsuite; + +const fn main() {}

diff --git reth/crates/seismic/node/tests/e2e/ops.rs seismic-reth/crates/seismic/node/tests/e2e/ops.rs new file mode 100644 index 0000000000000000000000000000000000000000..85efd5b0e52f34b9200c5b23f29b6a7fa38da3c9 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/ops.rs @@ -0,0 +1,285 @@ +//! E2E tests for ops whitelist/revoke via sentinel transactions in `eth_sendRawTransaction`. + +use alloy_consensus::SignableTransaction; +use alloy_eips::eip2718::Encodable2718; +use alloy_primitives::{address, Address, Bytes, TxKind, U256}; +use alloy_signer::{Signer, SignerSync}; +use alloy_signer_local::PrivateKeySigner; +use alloy_sol_types::{sol, SolCall}; +use jsonrpsee::{core::client::ClientT, http_client::HttpClientBuilder, rpc_params}; +use reth_chainspec::{make_genesis_header, Chain, ChainSpec}; +use reth_e2e_test_utils::wallet::Wallet; +use reth_node_builder::{EngineNodeLauncher, Node, NodeBuilder, NodeConfig, NodeHandle}; +use reth_node_core::args::{DevArgs, RpcServerArgs}; +use reth_primitives_traits::SealedHeader; +use reth_rpc_builder::RpcModuleSelection; +use reth_rpc_layer::{eip712_signing_hash, WHITELIST_TX_SENTINEL}; +use reth_seismic_node::{ + node::SeismicNode, + utils::e2e::{ensure_mock_purpose_keys, SEISMIC_TIMESTAMP_MULTIPLIER}, +}; +use reth_tasks::TaskManager; +use std::sync::Arc; + +sol! { + interface OpsWhitelistTxAuth { + function whitelistKey(address target, uint64 expiresAt) external; + function revokeKey(address target) external; + } +} + +/// The Params contract address. +const PARAMS_CONTRACT: Address = address!("0x0000000000000000000000000000506172616d73"); + +/// Build a Seismic dev chain spec with a custom governance address in the Params contract. +fn dev_chain_spec_with_governance(governance_address: Address) -> Arc<ChainSpec> { + let mut genesis: alloy_genesis::Genesis = + serde_json::from_str(include_str!("../../../chainspec/res/genesis/dev.json")) + .expect("deserialize dev genesis"); + + #[cfg(not(feature = "timestamp-in-seconds"))] + { + genesis.timestamp *= 1000; + } + + // Overwrite slot 0 of the Params contract with the governance address. + let mut value = [0u8; 32]; + value[12..].copy_from_slice(governance_address.as_slice()); + if let Some(account) = genesis.alloc.get_mut(&PARAMS_CONTRACT) { + if let Some(ref mut storage) = account.storage { + storage.insert(alloy_primitives::B256::ZERO, alloy_primitives::B256::from(value)); + } + } + + let hardforks = reth_seismic_forks::SEISMIC_DEV_HARDFORKS.clone(); + Arc::new(ChainSpec { + chain: Chain::from_id(5124), + genesis_header: SealedHeader::seal_slow(make_genesis_header(&genesis, &hardforks)), + genesis, + paris_block_and_final_difficulty: Some((0, U256::from(0))), + hardforks, + ..Default::default() + }) +} + +fn seismic_payload_attributes(timestamp: u64) -> reth_payload_builder::EthPayloadBuilderAttributes { + use alloy_primitives::B256; + use alloy_rpc_types_engine::PayloadAttributes; + reth_payload_builder::EthPayloadBuilderAttributes::new( + B256::ZERO, + PayloadAttributes { + timestamp: timestamp * SEISMIC_TIMESTAMP_MULTIPLIER, + prev_randao: B256::ZERO, + suggested_fee_recipient: Address::ZERO, + withdrawals: Some(vec![]), + parent_beacon_block_root: Some(B256::ZERO), + }, + ) +} + +/// Build and sign a legacy transaction targeting the sentinel address with the given calldata. +fn build_sentinel_tx(signer: &PrivateKeySigner, chain_id: u64, calldata: Bytes) -> Bytes { + let tx = alloy_consensus::TxLegacy { + chain_id: Some(chain_id), + nonce: 0, + gas_limit: 100_000, + gas_price: 0, + to: TxKind::Call(WHITELIST_TX_SENTINEL), + value: U256::ZERO, + input: calldata, + }; + + let sig = signer.sign_hash_sync(&tx.signature_hash()).expect("sign sentinel tx"); + let signed = tx.into_signed(sig); + let envelope = alloy_consensus::TxEnvelope::Legacy(signed); + Encodable2718::encoded_2718(&envelope).into() +} + +fn whitelist_calldata(target: Address, expires_at: u64) -> Bytes { + OpsWhitelistTxAuth::whitelistKeyCall { target, expiresAt: expires_at }.abi_encode().into() +} + +fn revoke_calldata(target: Address) -> Bytes { + OpsWhitelistTxAuth::revokeKeyCall { target }.abi_encode().into() +} + +fn current_unix_timestamp() -> u64 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .expect("system clock before unix epoch") + .as_secs() +} + +/// Send a signed request to the ops RPC server. +async fn send_ops_signed_request( + url: &str, + body: &str, + signer: &PrivateKeySigner, + nonce: Option<&str>, + chain_id: u64, +) -> reqwest::Response { + let signing_nonce = nonce.unwrap_or(""); + let hash = eip712_signing_hash(body.as_bytes(), signing_nonce, chain_id); + let signature = signer.sign_hash(&hash).await.unwrap(); + let sig_hex = alloy_primitives::hex::encode(signature.as_bytes()); + + let mut req = reqwest::Client::new() + .post(url) + .header("Content-Type", "application/json") + .header("X-Signature", &sig_hex); + if let Some(nonce) = nonce { + req = req.header("X-Nonce", nonce); + } + req.body(body.to_string()).send().await.unwrap() +} + +fn ops_get_storage_request(address: Address, slot: alloy_primitives::B256, id: u64) -> String { + serde_json::json!({ + "jsonrpc": "2.0", + "method": "ops_getStorageAt", + "params": [format!("{address:?}"), format!("{slot:?}"), "latest"], + "id": id + }) + .to_string() +} + +/// Launch a Seismic node with ops enabled and a custom governance address. +async fn launch_ops_node( + governance_signer: &PrivateKeySigner, +) -> eyre::Result<( + reth_e2e_test_utils::NodeHelperType< + SeismicNode, + reth_provider::providers::BlockchainProvider< + reth_node_api::NodeTypesWithDBAdapter<SeismicNode, reth_e2e_test_utils::TmpDB>, + >, + >, + TaskManager, + Wallet, +)> { + let chain_spec = dev_chain_spec_with_governance(governance_signer.address()); + let tasks = TaskManager::current(); + let exec = tasks.executor(); + + ensure_mock_purpose_keys(); + + let mut rpc_args = RpcServerArgs::default() + .with_unused_ports() + .with_http() + .with_http_api(RpcModuleSelection::All); + rpc_args.ops_enable = true; + rpc_args.ops_port = 0; // random unused port + + let node_config = NodeConfig::new(chain_spec) + .with_unused_ports() + .with_dev(DevArgs { dev: true, ..Default::default() }) + .with_rpc(rpc_args); + + let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config) + .testing_node(exec) + .with_types_and_provider::<SeismicNode, reth_provider::providers::BlockchainProvider<_>>() + .with_components(SeismicNode::default().components_builder()) + .with_add_ons(SeismicNode::default().add_ons()) + .launch_with_fn(|builder| { + let launcher = EngineNodeLauncher::new( + builder.task_executor().clone(), + builder.config().datadir(), + Default::default(), + ); + builder.launch_with(launcher) + }) + .await?; + + let node = + reth_e2e_test_utils::node::NodeTestContext::new(node, seismic_payload_attributes).await?; + let wallet = Wallet::default().with_chain_id(5124); + + Ok((node, tasks, wallet)) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_ops_sentinel_whitelist_from_governance_key() { + reth_tracing::init_test_tracing(); + let governance = PrivateKeySigner::random(); + let reader = PrivateKeySigner::random(); + + let (node, _tasks, _wallet) = launch_ops_node(&governance).await.unwrap(); + let rpc_url = node.rpc_url().to_string(); + let client = HttpClientBuilder::default().build(&rpc_url).unwrap(); + let chain_id = 5124u64; + + // Send a whitelist sentinel tx from governance key. + let expires_at = current_unix_timestamp() + 3600; + let raw_tx = + build_sentinel_tx(&governance, chain_id, whitelist_calldata(reader.address(), expires_at)); + let result: serde_json::Value = client + .request( + "eth_sendRawTransaction", + rpc_params![format!("0x{}", alloy_primitives::hex::encode(&raw_tx))], + ) + .await + .expect("whitelist sentinel tx should succeed"); + assert!(result.is_string(), "should return a tx hash"); + + // Now verify the reader is whitelisted by querying the ops server. + let ops_url = format!( + "http://{}", + node.inner + .rpc_server_handles() + .ops + .as_ref() + .expect("ops server should be running") + .local_addr() + ); + let body = ops_get_storage_request(PARAMS_CONTRACT, alloy_primitives::B256::ZERO, 1); + let resp = send_ops_signed_request(&ops_url, &body, &reader, Some("0"), chain_id).await; + assert_eq!( + resp.status(), + reqwest::StatusCode::OK, + "whitelisted reader should be able to read storage" + ); + + // Send a revoke sentinel tx. + let raw_tx = build_sentinel_tx(&governance, chain_id, revoke_calldata(reader.address())); + let result: serde_json::Value = client + .request( + "eth_sendRawTransaction", + rpc_params![format!("0x{}", alloy_primitives::hex::encode(&raw_tx))], + ) + .await + .expect("revoke sentinel tx should succeed"); + assert!(result.is_string(), "should return a tx hash"); + + // Reader should no longer be whitelisted. + let body = ops_get_storage_request(PARAMS_CONTRACT, alloy_primitives::B256::ZERO, 2); + let resp = send_ops_signed_request(&ops_url, &body, &reader, Some("1"), chain_id).await; + assert_eq!( + resp.status(), + reqwest::StatusCode::UNAUTHORIZED, + "revoked reader should be rejected" + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_ops_sentinel_whitelist_from_non_governance_key_fails() { + reth_tracing::init_test_tracing(); + let governance = PrivateKeySigner::random(); + let attacker = PrivateKeySigner::random(); + let target = PrivateKeySigner::random(); + + let (node, _tasks, _wallet) = launch_ops_node(&governance).await.unwrap(); + let rpc_url = node.rpc_url().to_string(); + let client = HttpClientBuilder::default().build(&rpc_url).unwrap(); + let chain_id = 5124u64; + + // Attacker tries to send a whitelist sentinel tx — should fail. + let expires_at = current_unix_timestamp() + 3600; + let raw_tx = + build_sentinel_tx(&attacker, chain_id, whitelist_calldata(target.address(), expires_at)); + let result = client + .request::<serde_json::Value, _>( + "eth_sendRawTransaction", + rpc_params![format!("0x{}", alloy_primitives::hex::encode(&raw_tx))], + ) + .await; + assert!(result.is_err(), "non-governance sentinel tx should be rejected"); +}

diff --git reth/crates/seismic/node/tests/e2e/p2p.rs seismic-reth/crates/seismic/node/tests/e2e/p2p.rs new file mode 100644 index 0000000000000000000000000000000000000000..c342d9fe43f43990ee8b5d31a214eeca878f2e15 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/p2p.rs @@ -0,0 +1,77 @@ +use futures::StreamExt; +use reth_seismic_node::utils::e2e::{advance_chain, ensure_mock_purpose_keys, setup}; +use std::sync::Arc; +use tokio::sync::Mutex; + +#[tokio::test] +async fn can_sync() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + ensure_mock_purpose_keys(); + + let (mut nodes, _tasks, wallet) = setup(3).await?; + let wallet = Arc::new(Mutex::new(wallet)); + + let third_node = nodes.pop().unwrap(); + let mut second_node = nodes.pop().unwrap(); + let mut first_node = nodes.pop().unwrap(); + + let tip: usize = 90; + let tip_index: usize = tip - 1; + let reorg_depth = 2; + + // On first node, create a chain up to block number 90a + let canonical_payload_chain = advance_chain(tip, &mut first_node, wallet.clone()).await?; + let canonical_chain = + canonical_payload_chain.iter().map(|p| p.block().hash()).collect::<Vec<_>>(); + + // On second node, sync optimistically up to block number 88a + second_node.update_optimistic_forkchoice(canonical_chain[tip_index - reorg_depth - 1]).await?; + second_node + .wait_block( + (tip - reorg_depth - 1) as u64, + canonical_chain[tip_index - reorg_depth - 1], + true, + ) + .await?; + // We send FCU twice to ensure that pool receives canonical chain update on the second FCU + // This is required because notifications are not sent during backfill sync + second_node.update_optimistic_forkchoice(canonical_chain[tip_index - reorg_depth]).await?; + second_node + .wait_block((tip - reorg_depth) as u64, canonical_chain[tip_index - reorg_depth], false) + .await?; + second_node.canonical_stream.next().await.unwrap(); + + // Trigger backfill sync until block 80 + third_node + .update_forkchoice(canonical_chain[tip_index - 10], canonical_chain[tip_index - 10]) + .await?; + third_node.wait_block((tip - 10) as u64, canonical_chain[tip_index - 10], true).await?; + // Trigger live sync to block 90 + third_node.update_optimistic_forkchoice(canonical_chain[tip_index]).await?; + third_node.wait_block(tip as u64, canonical_chain[tip_index], false).await?; + + // On second node, create a side chain: 88a -> 89b -> 90b + wallet.lock().await.inner_nonce -= reorg_depth as u64; + second_node.payload.timestamp = first_node.payload.timestamp - reorg_depth as u64; // TODO: probably want to make it node agnostic + let side_payload_chain = advance_chain(reorg_depth, &mut second_node, wallet.clone()).await?; + let side_chain = side_payload_chain.iter().map(|p| p.block().hash()).collect::<Vec<_>>(); + + // Creates fork chain by submitting 89b payload. + // By returning Valid here, op-node will finally return a finalized hash + let _ = third_node.submit_payload(side_payload_chain[0].clone()).await; + + // It will issue a pipeline reorg to 88a, and then make 89b canonical AND finalized. + third_node.update_forkchoice(side_chain[0], side_chain[0]).await?; + + // Make sure we have the updated block + third_node.wait_unwind((tip - reorg_depth) as u64).await?; + third_node + .wait_block( + side_payload_chain[0].block().number, + side_payload_chain[0].block().hash(), + false, + ) + .await?; + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/rpc.rs seismic-reth/crates/seismic/node/tests/e2e/rpc.rs new file mode 100644 index 0000000000000000000000000000000000000000..cbede6189eda8e80b3743e7f52c3379feba1d0e3 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/rpc.rs @@ -0,0 +1,268 @@ +use crate::utils::eth_payload_attributes; +use alloy_eips::{calc_next_block_base_fee, eip2718::Encodable2718}; +use alloy_primitives::{Address, B256, U256}; +use alloy_provider::{network::EthereumWallet, Provider, ProviderBuilder, SendableTx}; +use alloy_rpc_types_beacon::relay::{ + BidTrace, BuilderBlockValidationRequestV3, BuilderBlockValidationRequestV4, + SignedBidSubmissionV3, SignedBidSubmissionV4, +}; +use alloy_rpc_types_engine::{BlobsBundleV1, ExecutionPayloadV3}; +use alloy_rpc_types_eth::TransactionRequest; +use rand::{rngs::StdRng, Rng, SeedableRng}; +use reth_chainspec::{ChainSpecBuilder, MAINNET}; +use reth_e2e_test_utils::setup_engine; +use reth_node_ethereum::EthereumNode; +use reth_payload_primitives::BuiltPayload; +use std::sync::Arc; + +alloy_sol_types::sol! { + #[sol(rpc, bytecode = "6080604052348015600f57600080fd5b5060405160db38038060db833981016040819052602a91607a565b60005b818110156074576040805143602082015290810182905260009060600160408051601f19818403018152919052805160209091012080555080606d816092565b915050602d565b505060b8565b600060208284031215608b57600080fd5b5051919050565b60006001820160b157634e487b7160e01b600052601160045260246000fd5b5060010190565b60168060c56000396000f3fe6080604052600080fdfea164736f6c6343000810000a")] + contract GasWaster { + constructor(uint256 iterations) { + for (uint256 i = 0; i < iterations; i++) { + bytes32 slot = keccak256(abi.encode(block.number, i)); + assembly { + sstore(slot, slot) + } + } + } + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_fee_history() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let seed: [u8; 32] = rand::thread_rng().gen(); + let mut rng = StdRng::from_seed(seed); + println!("Seed: {:?}", seed); + + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .cancun_activated() + .build(), + ); + + let (mut nodes, _tasks, wallet) = + setup_engine::<EthereumNode>(1, chain_spec.clone(), false, eth_payload_attributes).await?; + let mut node = nodes.pop().unwrap(); + let provider = ProviderBuilder::new() + .wallet(EthereumWallet::new(wallet.gen().swap_remove(0))) + .on_http(node.rpc_url()); + + let fee_history = provider.get_fee_history(10, 0_u64.into(), &[]).await?; + + let genesis_base_fee = chain_spec.initial_base_fee().unwrap() as u128; + let expected_first_base_fee = genesis_base_fee - + genesis_base_fee / chain_spec.base_fee_params_at_block(0).max_change_denominator; + assert_eq!(fee_history.base_fee_per_gas[0], genesis_base_fee); + assert_eq!(fee_history.base_fee_per_gas[1], expected_first_base_fee,); + + // Spend some gas + let builder = GasWaster::deploy_builder(&provider, U256::from(500)).send().await?; + node.advance_block().await?; + let receipt = builder.get_receipt().await?; + assert!(receipt.status()); + + let block = provider.get_block_by_number(1.into()).await?.unwrap(); + assert_eq!(block.header.gas_used, receipt.gas_used,); + assert_eq!(block.header.base_fee_per_gas.unwrap(), expected_first_base_fee as u64); + + for _ in 0..100 { + let _ = + GasWaster::deploy_builder(&provider, U256::from(rng.gen_range(0..1000))).send().await?; + + node.advance_block().await?; + } + + let latest_block = provider.get_block_number().await?; + + for _ in 0..100 { + let latest_block = rng.gen_range(0..=latest_block); + let block_count = rng.gen_range(1..=(latest_block + 1)); + + let fee_history = provider.get_fee_history(block_count, latest_block.into(), &[]).await?; + + let mut prev_header = provider + .get_block_by_number((latest_block + 1 - block_count).into()) + .await? + .unwrap() + .header; + for block in (latest_block + 2 - block_count)..=latest_block { + let expected_base_fee = calc_next_block_base_fee( + prev_header.gas_used, + prev_header.gas_limit, + prev_header.base_fee_per_gas.unwrap(), + chain_spec.base_fee_params_at_block(block), + ); + + let header = provider.get_block_by_number(block.into()).await?.unwrap().header; + + assert_eq!(header.base_fee_per_gas.unwrap(), expected_base_fee); + assert_eq!( + header.base_fee_per_gas.unwrap(), + fee_history.base_fee_per_gas[(block + block_count - 1 - latest_block) as usize] + as u64 + ); + + prev_header = header; + } + } + + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_flashbots_validate_v3() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .cancun_activated() + .build(), + ); + + let (mut nodes, _tasks, wallet) = + setup_engine::<EthereumNode>(1, chain_spec.clone(), false, eth_payload_attributes).await?; + let mut node = nodes.pop().unwrap(); + let provider = ProviderBuilder::new() + .wallet(EthereumWallet::new(wallet.gen().swap_remove(0))) + .on_http(node.rpc_url()); + + node.advance(100, |_| { + let provider = provider.clone(); + Box::pin(async move { + let SendableTx::Envelope(tx) = + provider.fill(TransactionRequest::default().to(Address::ZERO)).await.unwrap() + else { + unreachable!() + }; + + tx.encoded_2718().into() + }) + }) + .await?; + + let _ = provider.send_transaction(TransactionRequest::default().to(Address::ZERO)).await?; + let payload = node.new_payload().await?; + + let mut request = BuilderBlockValidationRequestV3 { + request: SignedBidSubmissionV3 { + message: BidTrace { + parent_hash: payload.block().parent_hash, + block_hash: payload.block().hash(), + gas_used: payload.block().gas_used, + gas_limit: payload.block().gas_limit, + ..Default::default() + }, + execution_payload: ExecutionPayloadV3::from_block_unchecked( + payload.block().hash(), + &payload.block().clone().into_block(), + ), + blobs_bundle: BlobsBundleV1::new([]), + signature: Default::default(), + }, + parent_beacon_block_root: payload.block().parent_beacon_block_root.unwrap(), + registered_gas_limit: payload.block().gas_limit, + }; + + assert!(provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV3".into(), (&request,)) + .await + .is_ok()); + + request.registered_gas_limit -= 1; + assert!(provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV3".into(), (&request,)) + .await + .is_err()); + request.registered_gas_limit += 1; + + request.request.execution_payload.payload_inner.payload_inner.state_root = B256::ZERO; + assert!(provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV3".into(), (&request,)) + .await + .is_err()); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn test_flashbots_validate_v4() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .prague_activated() + .build(), + ); + + let (mut nodes, _tasks, wallet) = + setup_engine::<EthereumNode>(1, chain_spec.clone(), false, eth_payload_attributes).await?; + let mut node = nodes.pop().unwrap(); + let provider = ProviderBuilder::new() + .wallet(EthereumWallet::new(wallet.gen().swap_remove(0))) + .on_http(node.rpc_url()); + + node.advance(100, |_| { + let provider = provider.clone(); + Box::pin(async move { + let SendableTx::Envelope(tx) = + provider.fill(TransactionRequest::default().to(Address::ZERO)).await.unwrap() + else { + unreachable!() + }; + + tx.encoded_2718().into() + }) + }) + .await?; + + let _ = provider.send_transaction(TransactionRequest::default().to(Address::ZERO)).await?; + let payload = node.new_payload().await?; + + let mut request = BuilderBlockValidationRequestV4 { + request: SignedBidSubmissionV4 { + message: BidTrace { + parent_hash: payload.block().parent_hash, + block_hash: payload.block().hash(), + gas_used: payload.block().gas_used, + gas_limit: payload.block().gas_limit, + ..Default::default() + }, + execution_payload: ExecutionPayloadV3::from_block_unchecked( + payload.block().hash(), + &payload.block().clone().into_block(), + ), + blobs_bundle: BlobsBundleV1::new([]), + execution_requests: payload.requests().unwrap().try_into().unwrap(), + signature: Default::default(), + }, + parent_beacon_block_root: payload.block().parent_beacon_block_root.unwrap(), + registered_gas_limit: payload.block().gas_limit, + }; + + provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV4".into(), (&request,)) + .await + .expect("request should validate"); + + request.registered_gas_limit -= 1; + assert!(provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV4".into(), (&request,)) + .await + .is_err()); + request.registered_gas_limit += 1; + + request.request.execution_payload.payload_inner.payload_inner.state_root = B256::ZERO; + assert!(provider + .raw_request::<_, ()>("flashbots_validateBuilderSubmissionV4".into(), (&request,)) + .await + .is_err()); + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/rpc_compat.rs seismic-reth/crates/seismic/node/tests/e2e/rpc_compat.rs new file mode 100644 index 0000000000000000000000000000000000000000..07a5e43ff1789a0f6d0ab1c18fdd60ed42b59a1c --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/rpc_compat.rs @@ -0,0 +1,86 @@ +//! Seismic RPC compatibility tests using test data from a Summit testnet. +//! +//! These tests import a chain produced by a Summit testnet (real consensus, chain ID 5124) +//! and verify RPC responses against captured `.io` test files. + +use alloy_chains::Chain; +use alloy_genesis::Genesis; +use alloy_primitives::U256; +use eyre::Result; +use reth_chainspec::{make_genesis_header, ChainSpec}; +use reth_e2e_test_utils::testsuite::{ + actions::{MakeCanonical, UpdateBlockInfo}, + setup::{NetworkSetup, Setup}, + TestBuilder, +}; +use reth_primitives_traits::SealedHeader; +use reth_rpc_e2e_tests::rpc_compat::{InitializeFromExecutionApis, RunRpcCompatTests}; +use reth_seismic_evm::SeismicEvmConfig; +use reth_seismic_node::{ + engine::SeismicEngineTypes, node::SeismicNode, purpose_keys::get_purpose_keys, +}; +use std::{path::PathBuf, sync::Arc}; +use tracing::info; + +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_rpc_compat() -> Result<()> { + reth_tracing::init_test_tracing(); + reth_seismic_node::utils::e2e::ensure_mock_purpose_keys(); + + let test_data_path = + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/e2e/testdata/rpc-compat"); + assert!(test_data_path.exists(), "Test data path missing: {}", test_data_path.display()); + info!("Using Seismic test data from: {}", test_data_path.display()); + + let chain_rlp_path = test_data_path.join("chain.rlp"); + let fcu_json_path = test_data_path.join("headfcu.json"); + let genesis_path = test_data_path.join("genesis.json"); + + assert!(chain_rlp_path.exists(), "chain.rlp not found"); + assert!(fcu_json_path.exists(), "headfcu.json not found"); + assert!(genesis_path.exists(), "genesis.json not found"); + + // Load genesis from testdata so this test is decoupled from SEISMIC_DEV. + let genesis_json = + std::fs::read_to_string(&genesis_path).expect("failed to read genesis.json from testdata"); + let mut genesis: Genesis = serde_json::from_str(&genesis_json).expect("invalid genesis JSON"); + + // Genesis JSON timestamps are in seconds, but when timestamp-in-seconds feature is disabled, + // we store timestamps internally as milliseconds. + #[cfg(not(feature = "timestamp-in-seconds"))] + { + genesis.timestamp *= 1000; + } + + let hardforks = reth_seismic_forks::SEISMIC_DEV_HARDFORKS.clone(); + let chain_spec: Arc<ChainSpec> = ChainSpec { + chain: Chain::from_id(genesis.config.chain_id), + genesis_header: SealedHeader::seal_slow(make_genesis_header(&genesis, &hardforks)), + genesis, + paris_block_and_final_difficulty: Some((0, U256::from(0))), + hardforks, + ..Default::default() + } + .into(); + + let setup = Setup::<SeismicEngineTypes>::default() + .with_chain_spec(chain_spec.clone()) + .with_network(NetworkSetup::single_node()); + + let test = TestBuilder::new() + .with_setup_and_import(setup, chain_rlp_path) + .with_action(UpdateBlockInfo::default()) + .with_action( + InitializeFromExecutionApis::new().with_fcu_json(fcu_json_path.to_string_lossy()), + ) + .with_action(MakeCanonical::new()) + .with_action(RunRpcCompatTests::new( + vec!["eth_getLogs".to_string(), "eth_syncing".to_string()], + test_data_path.to_string_lossy(), + )); + + let evm_config = SeismicEvmConfig::new(chain_spec, get_purpose_keys()); + test.run_with_evm::<SeismicNode>(evm_config).await?; + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/chain.rlp seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/chain.rlp new file mode 100644 index 0000000000000000000000000000000000000000..09afc6cf44afc6ada5afd38f68aa0e8eb6409da9 Binary files /dev/null and seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/chain.rlp differ

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/contract-addr.io seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/contract-addr.io new file mode 100644 index 0000000000000000000000000000000000000000..3e8cd4450d8e41278c2adcc44406634bdb8a33bc --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/contract-addr.io @@ -0,0 +1,3 @@ +// queries for logs from a specific contract across a range of blocks +>> {"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"address":["0x5fbdb2315678afecb367f032d93f642f64180aa3"],"fromBlock":"0x15b","toBlock":"0x189","topics":null}]} +<< {"jsonrpc":"2.0","id":1,"result":[{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x1","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x2","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x3","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x4","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x5","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x6","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x7","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x8","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x9","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0x3aec5faba1c57465e0e66983f19b0f342f2afcd301ffc9fb021c4c3a07ce6984","blockNumber":"0x16f","blockTimestamp":"0x19d20f0a8b4","transactionHash":"0xfbb33943150d4407132c2ed152db37e284fcf6bbca1d487fcc57c65187e53186","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x54ce699289354829d667bc6b9d53bf7762254b99c8d6d72c3c4034a85859a4cb","0x0000000000000000000000000000000000000000000000000000000000000001","0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658"],"data":"0x","blockHash":"0x69686993ee74db804ccb5ee8f76d702bc52393056c40a0269840e8c24f0ab1cd","blockNumber":"0x17b","blockTimestamp":"0x19d20f0b9f3","transactionHash":"0x4ada27a2fd478ac1b1397689a90110b19a1c51a567fa04800dc13bf4410db5b3","transactionIndex":"0x0","logIndex":"0x0","removed":false}]}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/no-topics.io seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/no-topics.io new file mode 100644 index 0000000000000000000000000000000000000000..2ce81e4d20a76b525d11b49587913b2b04cd4b73 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/no-topics.io @@ -0,0 +1,3 @@ +// queries for all logs across a range of blocks +>> {"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"address":null,"fromBlock":"0x15b","toBlock":"0x17b","topics":null}]} +<< {"jsonrpc":"2.0","id":1,"result":[{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x1","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x2","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x3","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x4","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x5","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x6","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x7","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x8","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x9","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0x3aec5faba1c57465e0e66983f19b0f342f2afcd301ffc9fb021c4c3a07ce6984","blockNumber":"0x16f","blockTimestamp":"0x19d20f0a8b4","transactionHash":"0xfbb33943150d4407132c2ed152db37e284fcf6bbca1d487fcc57c65187e53186","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x54ce699289354829d667bc6b9d53bf7762254b99c8d6d72c3c4034a85859a4cb","0x0000000000000000000000000000000000000000000000000000000000000001","0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658"],"data":"0x","blockHash":"0x69686993ee74db804ccb5ee8f76d702bc52393056c40a0269840e8c24f0ab1cd","blockNumber":"0x17b","blockTimestamp":"0x19d20f0b9f3","transactionHash":"0x4ada27a2fd478ac1b1397689a90110b19a1c51a567fa04800dc13bf4410db5b3","transactionIndex":"0x0","logIndex":"0x0","removed":false}]}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-exact-match.io seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-exact-match.io new file mode 100644 index 0000000000000000000000000000000000000000..7b488ee20379665246b50acde62f355e66b4e88f --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-exact-match.io @@ -0,0 +1,3 @@ +// queries for logs with a specific topic +>> {"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"address":null,"fromBlock":"0x15b","toBlock":"0x189","topics":[["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"]]}]} +<< {"jsonrpc":"2.0","id":1,"result":[{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x0","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x1","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x2","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x3","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x4","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x5","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x6","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x7","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x8","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0xd6cd93b02476170483f6ab723f1ba5a282a30979bfd9b930f9e7ec531584673e","blockNumber":"0x167","blockTimestamp":"0x19d20f09cf2","transactionHash":"0xbd57265e3b975299238f73cb658d5b62c6f86e4010f7ae5f0ddddd10d4cce28c","transactionIndex":"0x0","logIndex":"0x9","removed":false},{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x4bbf2a95b8a1b0106078ab03fae6e70488f9b23dfd9c007e7e9f6058cc55233c"],"data":"0x","blockHash":"0x3aec5faba1c57465e0e66983f19b0f342f2afcd301ffc9fb021c4c3a07ce6984","blockNumber":"0x16f","blockTimestamp":"0x19d20f0a8b4","transactionHash":"0xfbb33943150d4407132c2ed152db37e284fcf6bbca1d487fcc57c65187e53186","transactionIndex":"0x0","logIndex":"0x0","removed":false}]}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-wildcard.io seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-wildcard.io new file mode 100644 index 0000000000000000000000000000000000000000..6f88f20146dea730dd669a257bf674e78451eb52 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_getLogs/topic-wildcard.io @@ -0,0 +1,3 @@ +// queries for logs with two topics, performing a wildcard match in topic position zero +>> {"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"address":null,"fromBlock":"0x15b","toBlock":"0x189","topics":[[],["0x0000000000000000000000000000000000000000000000000000000000000001"]]}]} +<< {"jsonrpc":"2.0","id":1,"result":[{"address":"0x5fbdb2315678afecb367f032d93f642f64180aa3","topics":["0x54ce699289354829d667bc6b9d53bf7762254b99c8d6d72c3c4034a85859a4cb","0x0000000000000000000000000000000000000000000000000000000000000001","0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658"],"data":"0x","blockHash":"0x69686993ee74db804ccb5ee8f76d702bc52393056c40a0269840e8c24f0ab1cd","blockNumber":"0x17b","blockTimestamp":"0x19d20f0b9f3","transactionHash":"0x4ada27a2fd478ac1b1397689a90110b19a1c51a567fa04800dc13bf4410db5b3","transactionIndex":"0x0","logIndex":"0x0","removed":false}]}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_syncing/eth_syncing.io seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_syncing/eth_syncing.io new file mode 100644 index 0000000000000000000000000000000000000000..4e2cef489e62a6aaf303dbe809556528e98be125 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/eth_syncing/eth_syncing.io @@ -0,0 +1,3 @@ +// checks client syncing status +>> {"jsonrpc":"2.0","id":1,"method":"eth_syncing","params":[]} +<< {"jsonrpc":"2.0","id":1,"result":false}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/forkenv.json seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/forkenv.json new file mode 100644 index 0000000000000000000000000000000000000000..06c526b62c4b6f60cb55860ee4d679549148fea9 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/forkenv.json @@ -0,0 +1,4 @@ +{ + "HIVE_CHAIN_ID": "5124", + "HIVE_NETWORK_ID": "5124" +}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/genesis.json seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/genesis.json new file mode 100644 index 0000000000000000000000000000000000000000..cad3eac93656056a2a6373a1a8630fd18a7da443 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/genesis.json @@ -0,0 +1,93 @@ +{ + "config": { + "berlinBlock": 0, + "byzantiumBlock": 0, + "cancunTime": 0, + "chainId": 5124, + "constantinopleBlock": 0, + "daoForkSupport": true, + "eip150Block": 0, + "eip155Block": 0, + "eip158Block": 0, + "ethash": {}, + "homesteadBlock": 0, + "istanbulBlock": 0, + "londonBlock": 0, + "osakaTime": 0, + "petersburgBlock": 0, + "pragueTime": 0, + "shanghaiTime": 0, + "terminalTotalDifficulty": 0 + }, + "alloc": { + "0x0000000000000000000000000000000000002001": { + "balance": "0x0", + "code": "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" + }, + "0x0000000000000000000000000000506172616d73": { + "balance": "0x0", + "code": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0xd412c5ecd343e264381ff15afc0ad78a67b79f35" + } + }, + "0x000f3df6d732807ef1319fb7b8bb8522d0beac02": { + "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5ffd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f5ffd5b62001fff4b064b81555f359062001fff015500", + "balance": "0x0" + }, + "0x00000000219ab540356cbb839cbe05303d7705fa": { + "balance": "0x0", + "code": "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" + }, + "0x00000961ef480eb55e80d19ad83579a64c007002": { + "balance": "0x0", + "code": "0x3373fffffffffffffffffffffffffffffffffffffffe1460cb5760115f54807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff146101f457600182026001905f5b5f82111560685781019083028483029004916001019190604d565b909390049250505036603814608857366101f457346101f4575f5260205ff35b34106101f457600154600101600155600354806003026004013381556001015f35815560010160203590553360601b5f5260385f601437604c5fa0600101600355005b6003546002548082038060101160df575060105b5f5b8181146101835782810160030260040181604c02815460601b8152601401816001015481526020019060020154807fffffffffffffffffffffffffffffffff00000000000000000000000000000000168252906010019060401c908160381c81600701538160301c81600601538160281c81600501538160201c81600401538160181c81600301538160101c81600201538160081c81600101535360010160e1565b910180921461019557906002556101a0565b90505f6002555f6003555b5f54807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff14156101cd57505f5b6001546002828201116101e25750505f6101e8565b01600290035b5f555f600155604c025ff35b5f5ffd" + }, + "0x1000000000000000000000000000000000000001": { + "balance": "0x0", + "code": "0x60806040526004361015610013575b61071b565b61001d5f3561007c565b806344c0b2bf146100775780637a737c37146100725780638da5cb5b1461006d57806391fef11614610068578063a409c6f0146100635763b115ce0d0361000e576106e6565b610605565b61052d565b61042a565b610397565b61023b565b60e01c90565b60405190565b5f80fd5b5f80fd5b5f80fd5b5f80fd5b5f80fd5b601f801991011690565b634e487b7160e01b5f52604160045260245ffd5b906100c49061009c565b810190811067ffffffffffffffff8211176100de57604052565b6100a6565b906100f66100ef610082565b92836100ba565b565b67ffffffffffffffff81116101165761011260209161009c565b0190565b6100a6565b90825f939282370152565b9092919261013b610136826100f8565b6100e3565b93818552602085019082840111610157576101559261011b565b565b610098565b9080601f8301121561017a5781602061017793359101610126565b90565b610094565b151590565b61018d8161017f565b0361019457565b5f80fd5b905035906101a582610184565b565b608081830312610231575f81013567ffffffffffffffff811161022c57826101d091830161015c565b92602082013567ffffffffffffffff811161022757836101f191840161015c565b9260408301359067ffffffffffffffff8211610222576102168161021f93860161015c565b93606001610198565b90565b610090565b610090565b610090565b61008c565b5f0190565b3461026d5761025761024e3660046101a7565b92919091610a62565b61025f610082565b8061026981610236565b0390f35b610088565b5f80fd5b5f80fd5b9190916080818403126103385761029160806100e3565b925f82013567ffffffffffffffff811161033357816102b191840161015c565b5f850152602082013567ffffffffffffffff811161032e57816102d591840161015c565b6020850152604082013567ffffffffffffffff811161032957816102fa91840161015c565b6040850152606082013567ffffffffffffffff81116103245761031d920161015c565b6060830152565b610276565b610276565b610276565b610276565b610272565b9060208282031261036d575f82013567ffffffffffffffff811161036857610365920161027a565b90565b610090565b61008c565b90565b61037e90610372565b9052565b9190610395905f60208501940190610375565b565b346103c7576103c36103b26103ad36600461033d565b610c35565b6103ba610082565b91829182610382565b0390f35b610088565b5f9103126103d657565b61008c565b60026001609c1b0190565b6103ee6103db565b90565b60018060a01b031690565b610405906103f1565b90565b610411906103fc565b9052565b9190610428905f60208501940190610408565b565b3461045a5761043a3660046103cc565b6104566104456103e6565b61044d610082565b91829182610415565b0390f35b610088565b9190916060818403126104f35761047660606100e3565b925f82013567ffffffffffffffff81116104ee578161049691840161015c565b5f850152602082013567ffffffffffffffff81116104e957816104ba91840161015c565b6020850152604082013567ffffffffffffffff81116104e4576104dd920161015c565b6040830152565b610276565b610276565b610276565b610272565b90602082820312610528575f82013567ffffffffffffffff811161052357610520920161045f565b90565b610090565b61008c565b3461055d576105596105486105433660046104f8565b610cdc565b610550610082565b91829182610382565b0390f35b610088565b916060838303126105de575f83013567ffffffffffffffff81116105d9578261058c91850161015c565b92602081013567ffffffffffffffff81116105d457836105ad91830161015c565b92604082013567ffffffffffffffff81116105cf576105cc920161015c565b90565b610090565b610090565b610090565b61008c565b6105ec9061017f565b9052565b9190610603905f602085019401906105e3565b565b346106365761063261062161061b366004610562565b91610d4f565b610629610082565b918291826105f0565b0390f35b610088565b61064481610372565b0361064b57565b5f80fd5b9050359061065c8261063b565b565b9060208282031261067757610674915f0161064f565b90565b61008c565b61068590610372565b90565b906106929061067c565b5f5260205260405f2090565b1c90565b60ff1690565b6106b89060086106bd930261069e565b6106a2565b90565b906106cb91546106a8565b90565b6106e3906106de5f915f92610688565b6106c0565b90565b34610716576107126107016106fc36600461065e565b6106ce565b610709610082565b918291826105f0565b0390f35b610088565b5f80fd5b60209181520190565b5f7f4f6e6c79206f776e65722063616e207365742073746174757300000000000000910152565b61075c601960209261071f565b61076581610728565b0190565b61077e9060208101905f81830391015261074f565b90565b1561078857565b610790610082565b62461bcd60e51b8152806107a660048201610769565b0390fd5b5190565b90565b90565b90565b6107cb6107c66107d0926107b1565b6107b4565b6107ae565b90565b5f7f496e76616c6964206d727464206c656e67746800000000000000000000000000910152565b610807601360209261071f565b610810816107d3565b0190565b6108299060208101905f8183039101526107fa565b90565b1561083357565b61083b610082565b62461bcd60e51b81528061085160048201610814565b0390fd5b5f7f496e76616c6964206d727365616d206c656e6774680000000000000000000000910152565b610889601560209261071f565b61089281610855565b0190565b6108ab9060208101905f81830391015261087c565b90565b156108b557565b6108bd610082565b62461bcd60e51b8152806108d360048201610896565b0390fd5b90565b6108ee6108e96108f3926108d7565b6107b4565b6107ae565b90565b5f7f496e76616c69642070637234206c656e67746800000000000000000000000000910152565b61092a601360209261071f565b610933816108f6565b0190565b61094c9060208101905f81830391015261091d565b90565b1561095657565b61095e610082565b62461bcd60e51b81528061097460048201610937565b0390fd5b61098260606100e3565b90565b52565b5f1b90565b9061099960ff91610988565b9181191691161790565b6109ac9061017f565b90565b90565b906109c76109c26109ce926109a3565b6109af565b825461098d565b9055565b60209181520190565b90825f9392825e0152565b610a05610a0e602093610a13936109fc816107aa565b938480936109d2565b958691016109db565b61009c565b0190565b949391610a6093610a4a610a5892610a3c60609560808b01908b82035f8d01526109e6565b9089820360208b01526109e6565b9087820360408901526109e6565b9401906105e3565b565b610b7990610a8933610a83610a7d610a786103db565b6103fc565b916103fc565b14610781565b610aae610a95826107aa565b610aa8610aa260306107b7565b916107ae565b1461082c565b610ad3610aba846107aa565b610acd610ac760306107b7565b916107ae565b146108ae565b610af8610adf856107aa565b610af2610aec60206108da565b916107ae565b1461094f565b610b43610b3382610b2e86610b258991610b1c610b13610978565b955f8701610985565b60208501610985565b60408301610985565b610cdc565b610b3e87915f610688565b6109b2565b9192937ffbd013ecb3bb070127bc1b1186c451c2a5778c62b56de1db228acce4c28038ea94610b70610082565b94859485610a17565b0390a1565b5f90565b60209181520190565b610baa610bb3602093610bb893610ba1816107aa565b93848093610b82565b958691016109db565b61009c565b0190565b610c14916060610c03610bf1610bdf608085015f8701518682035f880152610b8b565b60208601518582036020870152610b8b565b60408501518482036040860152610b8b565b920151906060818403910152610b8b565b90565b610c2c9160208201915f818403910152610bbc565b90565b60200190565b610c68610c5991610c44610b7e565b50610c4d610082565b92839160208301610c17565b602082018103825203826100ba565b610c7a610c74826107aa565b91610c2f565b2090565b610cc1916040610cb0610c9e606084015f8601518582035f870152610b8b565b60208501518482036020860152610b8b565b920151906040818403910152610b8b565b90565b610cd99160208201915f818403910152610c7e565b90565b610d0f610d0091610ceb610b7e565b50610cf4610082565b92839160208301610cc4565b602082018103825203826100ba565b610d21610d1b826107aa565b91610c2f565b2090565b5f90565b5f1c90565b610d3a610d3f91610d29565b6106a2565b90565b610d4c9054610d2e565b90565b610e0b91610e00610e1094610df7610e0594610d69610d25565b50610d8f610d76826107aa565b610d89610d8360306107b7565b916107ae565b1461082c565b610db4610d9b866107aa565b610dae610da860306107b7565b916107ae565b146108ae565b610dd9610dc0846107aa565b610dd3610dcd60206108da565b916107ae565b1461094f565b93610dee610de5610978565b955f8701610985565b60208501610985565b60408301610985565b610cdc565b5f610688565b610d42565b9056fea26469706673582212209c9e77189674da6a0061a74e49989970b3eebaadb84294b33acb051b808ab37164736f6c637829302e382e33312d646576656c6f702e323032352e31312e31322b636f6d6d69742e3637366264656363005a" + }, + "0x1000000000000000000000000000000000000002": { + "balance": "0x0", + "code": "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" + }, + "0x1000000000000000000000000000000000000003": { + "balance": "0x0", + "code": "0x60806040526004361015610013575b61049a565b61001d5f3561006c565b8063415028a914610067578063727c346d14610062578063ad28a8161461005d578063baefa307146100585763e8d6c79a0361000e5761046e565b6103db565b61036d565b6102ff565b610245565b60e01c90565b60405190565b5f80fd5b5f80fd5b5f80fd5b5f80fd5b601f801991011690565b634e487b7160e01b5f52604160045260245ffd5b906100b090610088565b810190811067ffffffffffffffff8211176100ca57604052565b610092565b906100e26100db610072565b92836100a6565b565b67ffffffffffffffff8111610102576100fe602091610088565b0190565b610092565b90825f939282370152565b90929192610127610122826100e4565b6100cf565b938185526020850190828401116101435761014192610107565b565b610084565b9080601f830112156101665781602061016393359101610112565b90565b610080565b6bffffffffffffffffffffffff1690565b6101858161016b565b0361018c57565b5f80fd5b9050359061019d8261017c565b565b91906040838203126101df575f8301359067ffffffffffffffff82116101da576101ce816101d7938601610148565b93602001610190565b90565b61007c565b610078565b5190565b60209181520190565b90825f9392825e0152565b61021b61022460209361022993610212816101e4565b938480936101e8565b958691016101f1565b610088565b0190565b6102429160208201915f8184039101526101fc565b90565b61026d61025c61025636600461019f565b90610513565b610264610072565b9182918261022d565b0390f35b5f91031261027b57565b610078565b90565b60018060a01b031690565b90565b6102a56102a06102aa92610280565b61028e565b610283565b90565b6102b690610291565b90565b6102c360686102ad565b90565b6102ce6102b9565b90565b6102da90610283565b90565b6102e6906102d1565b9052565b91906102fd905f602085019401906102dd565b565b61030a366004610271565b6103266103156102c6565b61031d610072565b918291826102ea565b0390f35b90565b61034161033c6103469261032a565b61028e565b610283565b90565b6103529061032d565b90565b61035f6067610349565b90565b61036a610355565b90565b610378366004610271565b610394610383610362565b61038b610072565b918291826102ea565b0390f35b90565b6103af6103aa6103b492610398565b61028e565b610283565b90565b6103c09061039b565b90565b6103cd60666103b7565b90565b6103d86103c3565b90565b6103e6366004610271565b6104026103f16103d0565b6103f9610072565b918291826102ea565b0390f35b90602082820312610436575f82013567ffffffffffffffff81116104315761042e9201610148565b90565b61007c565b610078565b6104449061016b565b9052565b9291602061046461046c9360408701908782035f8901526101fc565b94019061043b565b565b61048161047c366004610406565b610739565b9061049661048d610072565b92839283610448565b0390f35b5f80fd5b606090565b905090565b6104cd6104c4926020926104bb816101e4565b948580936104a3565b938491016101f1565b0190565b60a01b90565b6104e0906104d1565b90565b6104ef6104f49161016b565b6104d7565b9052565b61050861050f91600c94936104a8565b80926104e3565b0190565b6105469061051f61049e565b5061053761052b610072565b938492602084016104f8565b602082018103825203826100a6565b90565b5f90565b90565b90565b61056761056261056c9261054d565b61028e565b610550565b90565b634e487b7160e01b5f52601160045260245ffd5b61059261059891939293610550565b92610550565b82039182116105a357565b61056f565b906105ba6105b5836100e4565b6100cf565b918252565b369037565b906105e96105d1836105a8565b926020806105df86936100e4565b92019103906105bf565b565b90565b6106026105fd610607926105eb565b61028e565b610550565b90565b60016106169101610550565b90565b634e487b7160e01b5f52603260045260245ffd5b90610637826101e4565b81101561064957600160209102010190565b610619565b60ff60f81b1690565b610661905161064e565b90565b61067361067991939293610550565b92610550565b820180921161068457565b61056f565b60200190565b6bffffffffffffffffffffffff60a01b1690565b6106ad905161068f565b90565b1b90565b6106ce6106c96106c3836101e4565b92610689565b6106a3565b90600c81106106dc575b5090565b6106fc906bffffffffffffffffffffffff60a01b90600c036008026106b0565b165f6106d8565b60a01c90565b61071d6107186107229261016b565b61028e565b61016b565b90565b61073161073691610703565b610709565b90565b9061074261049e565b5061074b610549565b50610768610758836101e4565b610762600c610553565b90610583565b610771816105c4565b9061077b5f6105ee565b5b8061078f61078984610550565b91610550565b10156107c6576107c1906107ac6107a787839061062d565b610657565b6107bb859183905f1a9261062d565b5361060a565b61077c565b50926107da6107d5600c610553565b6105c4565b916107e45f6105ee565b5b806107f96107f3600c610553565b91610550565b101561083a576108359061082061081b856108158a8590610664565b9061062d565b610657565b61082f869183905f1a9261062d565b5361060a565b6107e5565b5093505061084a61084f916106b4565b610725565b9056fea2646970667358221220f9203a71c0b6a6da16bf7b2698301c72ec306733882bb85b4d6d1038767c731464736f6c637829302e382e33312d646576656c6f702e323032352e31312e31322b636f6d6d69742e3637366264656363005a" + }, + "0x1000000000000000000000000000000000000004": { + "balance": "0x0", + "code": "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" + }, + "0x1000000000000000000000000000000000000005": { + "balance": "0x0", + "code": "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" + }, + "0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc": { + "balance": "0xD3C21BCECCEDA1000000" + }, + "0x70997970c51812dc3a010c7d01b50e0d17dc79c8": { + "balance": "0xD3C21BCECCEDA1000000" + }, + "0x90f79bf6eb2c4f870365e785982e1f101e93b906": { + "balance": "0xD3C21BCECCEDA1000000" + }, + "0xd412c5ecd343e264381ff15afc0ad78a67b79f35": { + "balance": "0x2000000000000000000000000000000000000000000000000000000000000000" + }, + "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266": { + "balance": "0xD3C21BCECCEDA1000000" + } + }, + "coinbase": "0x0000000000000000000000000000000000000000", + "difficulty": "0x0", + "extraData": "0x", + "gasLimit": "0x1c9c380", + "gasUsed": "0x0", + "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "nonce": "0x0", + "number": "0x0", + "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5eb6e371a698b8d68f665192350ffcecbbbf322916f4b51bd79bb6887da3f494", + "timestamp": "0x6490fdd2" +}

diff --git reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/headfcu.json seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/headfcu.json new file mode 100644 index 0000000000000000000000000000000000000000..d783f99363a9ea1520ee213761dda2a4e6178a07 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testdata/rpc-compat/headfcu.json @@ -0,0 +1,13 @@ +{ + "jsonrpc": "2.0", + "id": "fcu45", + "method": "engine_forkchoiceUpdatedV3", + "params": [ + { + "headBlockHash": "0xd5e69e4c67084751403c08f1bf816a42668470f292df03109769164b09cf756f", + "safeBlockHash": "0xd5e69e4c67084751403c08f1bf816a42668470f292df03109769164b09cf756f", + "finalizedBlockHash": "0xd5e69e4c67084751403c08f1bf816a42668470f292df03109769164b09cf756f" + }, + null + ] +}

diff --git reth/crates/seismic/node/tests/e2e/testsuite.rs seismic-reth/crates/seismic/node/tests/e2e/testsuite.rs new file mode 100644 index 0000000000000000000000000000000000000000..22d956f258d97f9e2cfe8e257797a60d6a73c664 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/testsuite.rs @@ -0,0 +1,36 @@ +use alloy_eips::eip2718::Encodable2718; +use alloy_primitives::{Address, U256}; +use alloy_rpc_types_eth::TransactionRequest; +use eyre::Result; +use reth_e2e_test_utils::transaction::TransactionTestContext; +use reth_seismic_node::utils::e2e::ensure_mock_purpose_keys; + +// Produces a single block on a Seismic node using the internal engine channel +// (not the JSON-RPC engine API, which loses Prague-era fields in V3 payloads). +#[tokio::test(flavor = "multi_thread")] +async fn test_seismic_produce_blocks() -> Result<()> { + reth_tracing::init_test_tracing(); + ensure_mock_purpose_keys(); + + let (mut nodes, _tasks, wallet) = reth_seismic_node::utils::e2e::setup(1).await?; + let mut node = nodes.pop().unwrap(); + + let tx = TransactionRequest { + nonce: Some(0), + value: Some(U256::from(100)), + to: Some(alloy_primitives::TxKind::Call(Address::random())), + gas: Some(21000), + max_fee_per_gas: Some(20e9 as u128), + max_priority_fee_per_gas: Some(20e9 as u128), + chain_id: Some(wallet.chain_id), + ..Default::default() + }; + let signed = TransactionTestContext::sign_tx(wallet.inner.clone(), tx).await; + let raw_tx: alloy_primitives::Bytes = signed.encoded_2718().into(); + + let tx_hash = node.rpc.inject_tx(raw_tx).await?; + let payload = node.advance_block().await?; + node.assert_new_block(tx_hash, payload.block().hash(), payload.block().number).await?; + + Ok(()) +}

diff --git reth/crates/seismic/node/tests/e2e/utils.rs seismic-reth/crates/seismic/node/tests/e2e/utils.rs new file mode 100644 index 0000000000000000000000000000000000000000..d889067b4ca8295676fef85f50bf4109dc4f1fcf --- /dev/null +++ seismic-reth/crates/seismic/node/tests/e2e/utils.rs @@ -0,0 +1,396 @@ +use alloy_eips::{eip2930::AccessListItem, eip7702::Authorization, BlockId, BlockNumberOrTag}; +use alloy_primitives::{bytes, Address, B256, U256}; +use alloy_provider::{ + network::{ + Ethereum, EthereumWallet, NetworkWallet, TransactionBuilder, TransactionBuilder7702, + }, + Provider, ProviderBuilder, SendableTx, +}; +use alloy_rpc_types_engine::PayloadAttributes; +use alloy_rpc_types_eth::TransactionRequest; +use alloy_signer::SignerSync; +use rand::{seq::SliceRandom, Rng}; +use reth_e2e_test_utils::{wallet::Wallet, NodeHelperType, TmpDB}; +use reth_ethereum_engine_primitives::PayloadBuilderAttributes; +use reth_ethereum_primitives::TxType; +use reth_node_api::NodeTypesWithDBAdapter; +use reth_node_ethereum::EthereumNode; +use reth_provider::FullProvider; + +/// Helper function to create a new eth payload attributes +pub(crate) fn eth_payload_attributes(timestamp: u64) -> PayloadBuilderAttributes { + let attributes = PayloadAttributes { + timestamp, + prev_randao: B256::ZERO, + suggested_fee_recipient: Address::ZERO, + withdrawals: Some(vec![]), + parent_beacon_block_root: Some(B256::ZERO), + }; + PayloadBuilderAttributes::new(B256::ZERO, attributes) +} + +/// Advances node by producing blocks with random transactions. +pub(crate) async fn advance_with_random_transactions<Provider>( + node: &mut NodeHelperType<EthereumNode, Provider>, + num_blocks: usize, + rng: &mut impl Rng, + finalize: bool, +) -> eyre::Result<()> +where + Provider: FullProvider<NodeTypesWithDBAdapter<EthereumNode, TmpDB>>, +{ + let provider = ProviderBuilder::new().on_http(node.rpc_url()); + let signers = Wallet::new(1).with_chain_id(provider.get_chain_id().await?).gen(); + + // simple contract which writes to storage on any call + let dummy_bytecode = bytes!("6080604052348015600f57600080fd5b50602880601d6000396000f3fe4360a09081523360c0526040608081905260e08152902080805500fea164736f6c6343000810000a"); + let mut call_destinations = signers.iter().map(|s| s.address()).collect::<Vec<_>>(); + + for _ in 0..num_blocks { + let tx_count = rng.gen_range(1..20); + + let mut pending = vec![]; + for _ in 0..tx_count { + let signer = signers.choose(rng).unwrap(); + let tx_type = TxType::try_from(rng.gen_range(0..=4) as u64).unwrap(); + + let nonce = provider + .get_transaction_count(signer.address()) + .block_id(BlockId::Number(BlockNumberOrTag::Pending)) + .await?; + + let mut tx = + TransactionRequest::default().with_from(signer.address()).with_nonce(nonce); + + let should_create = + rng.gen::<bool>() && tx_type != TxType::Eip4844 && tx_type != TxType::Eip7702; + if should_create { + tx = tx.into_create().with_input(dummy_bytecode.clone()); + } else { + tx = tx.with_to(*call_destinations.choose(rng).unwrap()).with_input( + (0..rng.gen_range(0..10000)).map(|_| rng.gen()).collect::<Vec<u8>>(), + ); + } + + if matches!(tx_type, TxType::Legacy | TxType::Eip2930) { + tx = tx.with_gas_price(provider.get_gas_price().await?); + } + + if rng.gen::<bool>() || tx_type == TxType::Eip2930 { + tx = tx.with_access_list( + vec![AccessListItem { + address: *call_destinations.choose(rng).unwrap(), + storage_keys: (0..rng.gen_range(0..100)).map(|_| rng.gen()).collect(), + }] + .into(), + ); + } + + if tx_type == TxType::Eip7702 { + let signer = signers.choose(rng).unwrap(); + let auth = Authorization { + chain_id: U256::from(provider.get_chain_id().await?), + address: *call_destinations.choose(rng).unwrap(), + nonce: provider + .get_transaction_count(signer.address()) + .block_id(BlockId::Number(BlockNumberOrTag::Pending)) + .await?, + }; + let sig = signer.sign_hash_sync(&auth.signature_hash())?; + tx = tx.with_authorization_list(vec![auth.into_signed(sig)]) + } + + let gas = provider + .estimate_gas(tx.clone()) + .block(BlockId::Number(BlockNumberOrTag::Pending)) + .await + .unwrap_or(1_000_000); + + tx.set_gas_limit(gas); + + let SendableTx::Builder(tx) = provider.fill(tx).await? else { unreachable!() }; + let tx = + NetworkWallet::<Ethereum>::sign_request(&EthereumWallet::new(signer.clone()), tx) + .await?; + + pending.push(provider.send_tx_envelope(tx).await?); + } + + let payload = node.build_and_submit_payload().await?; + if finalize { + node.update_forkchoice(payload.block().hash(), payload.block().hash()).await?; + } else { + let last_safe = + provider.get_block_by_number(BlockNumberOrTag::Safe).await?.unwrap().header.hash; + node.update_forkchoice(last_safe, payload.block().hash()).await?; + } + + for pending in pending { + let receipt = pending.get_receipt().await?; + if let Some(address) = receipt.contract_address { + call_destinations.push(address); + } + } + } + + Ok(()) +} + +/// Test utils for the seismic rpc api +#[cfg(test)] +pub mod test_utils { + use super::*; + use crate::ext::test_address; + use alloy_consensus::{SignableTransaction, TxEnvelope, TypedTransaction}; + use alloy_dyn_abi::TypedData; + use alloy_eips::eip2718::Encodable2718; + use alloy_primitives::{ + aliases::U96, hex_literal, Address, Bytes, PrimitiveSignature, TxKind, B256, U256, + }; + use alloy_rpc_types::{ + engine::PayloadAttributes, Block, Header, Transaction, TransactionInput, TransactionReceipt, + }; + use alloy_rpc_types_eth::TransactionRequest; + use alloy_signer_local::PrivateKeySigner; + use core::str::FromStr; + use enr::EnrKey; + use jsonrpsee::http_client::HttpClient; + use jsonrpsee_core::server::Methods; + use k256::ecdsa::SigningKey; + use reth_chainspec::MAINNET; + use reth_e2e_test_utils::transaction::TransactionTestContext; + use reth_enclave::MockEnclaveServer; + use reth_network_api::noop::NoopNetwork; + use reth_payload_builder::EthPayloadBuilderAttributes; + use reth_primitives::TransactionSigned; + use reth_provider::StateProviderFactory; + use reth_rpc::EthApi; + use reth_rpc_builder::{ + RpcModuleSelection, RpcServerConfig, RpcServerHandle, TransportRpcModuleConfig, + }; + use reth_rpc_eth_api::EthApiClient; + use reth_seismic_chainspec::SEISMIC_DEV; + use reth_seismic_primitives::{SeismicPrimitives, SeismicTransactionSigned}; + use reth_transaction_pool::test_utils::TestPool; + use secp256k1::{PublicKey, SecretKey}; + use seismic_alloy_consensus::{ + SeismicTxEnvelope::Seismic, SeismicTypedTransaction, TxSeismic, TxSeismicElements, + TypedDataRequest, + }; + use seismic_alloy_rpc_types::SeismicTransactionRequest; + use serde_json::Value; + use std::{path::PathBuf, process::Stdio, sync::Arc}; + use tokio::{ + io::{AsyncBufReadExt, AsyncWriteExt, BufReader}, + process::Command, + sync::mpsc, + }; + // use reth_seismic_evm::engine::SeismicEngineValidator; + + /// Get the nonce from the client + pub async fn get_nonce(client: &HttpClient, address: Address) -> u64 { + let nonce = + EthApiClient::<Transaction, Block, TransactionReceipt, Header>::transaction_count( + client, address, None, + ) + .await + .unwrap(); + nonce.wrapping_to::<u64>() + } + + /// Get an unsigned seismic transaction request + pub async fn get_unsigned_seismic_tx_request( + sk_wallet: &PrivateKeySigner, + nonce: u64, + to: TxKind, + chain_id: u64, + plaintext: Bytes, + ) -> SeismicTransactionRequest { + SeismicTransactionRequest { + inner: TransactionRequest { + from: Some(sk_wallet.address()), + nonce: Some(nonce), + value: Some(U256::from(0)), + to: Some(to), + gas: Some(6000000), + gas_price: Some(20e9 as u128), + chain_id: Some(chain_id), + input: TransactionInput { input: Some(client_encrypt(&plaintext)), data: None }, + transaction_type: Some(TxSeismic::TX_TYPE), + ..Default::default() + }, + seismic_elements: Some(get_seismic_elements()), + } + } + + // /// Create a seismic transaction + // pub async fn get_signed_seismic_tx_bytes( + // sk_wallet: &PrivateKeySigner, + // nonce: u64, + // to: TxKind, + // chain_id: u64, + // plaintext: Bytes, + // ) -> Bytes { + // let mut tx = get_unsigned_seismic_tx_request(sk_wallet, nonce, to, chain_id, + // plaintext).await; let signed_inner = + // TransactionTestContext::sign_tx(sk_wallet.clone(), tx.inner).await; tx.inner = + // signed_inner.into(); <TxEnvelope as Encodable2718>::encoded_2718(&tx).into() + // } + + // /// Get an unsigned seismic transaction typed data + // pub async fn get_unsigned_seismic_tx_typed_data( + // sk_wallet: &PrivateKeySigner, + // nonce: u64, + // to: TxKind, + // chain_id: u64, + // decrypted_input: Bytes, + // ) -> TypedData { + // let tx_request = + // get_unsigned_seismic_tx_request(sk_wallet, nonce, to, chain_id, + // decrypted_input).await; let typed_tx = + // tx_request.inner.build_consensus_tx().unwrap(); match typed_tx { + // SeismicTypedTransaction::Seismic(seismic) => seismic.eip712_to_type_data(), + // _ => panic!("Typed transaction is not a seismic transaction"), + // } + // } + + // /// Create a seismic transaction with typed data + // pub async fn get_signed_seismic_tx_typed_data( + // sk_wallet: &PrivateKeySigner, + // nonce: u64, + // to: TxKind, + // chain_id: u64, + // plaintext: Bytes, + // ) -> TypedDataRequest { + // let mut tx: SeismicTransactionRequest = get_unsigned_seismic_tx_request(sk_wallet, nonce, + // to, chain_id, plaintext).await; tx.seismic_elements.unwrap().message_version = 2; + // let signed_inner = TransactionTestContext::sign_tx(sk_wallet.clone(), tx.inner).await; + + // tx.inner = signed_inner.into(); + // tx + + // // let tx = get_unsigned_seismic_tx_request(sk_wallet, nonce, to, chain_id, + // plaintext).await; // tx.seismic_elements.unwrap().message_version = 2; + // // let signed = TransactionTestContext::sign_tx(sk_wallet.clone(), tx).await; + + // // match signed { + // // Seismic(tx) => tx.into(), + // // _ => panic!("Signed transaction is not a seismic transaction"), + // // } + // } + + /// Get the network public key + pub fn get_network_public_key() -> PublicKey { + MockEnclaveServer::get_public_key() + } + + /// Encrypt plaintext using network public key and client private key + pub fn get_ciphertext() -> Bytes { + let encrypted_data = client_encrypt(&get_plaintext()); + encrypted_data + } + + /// Encrypt plaintext using network public key and client private key + pub fn client_encrypt(plaintext: &Bytes) -> Bytes { + get_seismic_elements() + .client_encrypt(plaintext, &get_network_public_key(), &get_encryption_private_key()) + .unwrap() + } + + /// Decrypt ciphertext using network public key and client private key + pub fn client_decrypt(ciphertext: &Bytes) -> Bytes { + get_seismic_elements() + .client_decrypt(ciphertext, &get_network_public_key(), &get_encryption_private_key()) + .unwrap() + } + + /// Get the encryption private key + pub fn get_encryption_private_key() -> SecretKey { + let private_key_bytes = + hex_literal::hex!("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"); + SecretKey::from_slice(&private_key_bytes).expect("Invalid private key") + } + + /// Get the encryption nonce + pub fn get_encryption_nonce() -> U96 { + U96::MAX + } + + /// Get the seismic elements + pub fn get_seismic_elements() -> TxSeismicElements { + TxSeismicElements { + encryption_pubkey: get_encryption_private_key().public(), + encryption_nonce: get_encryption_nonce(), + message_version: 0, + } + } + + /// Get a wrong private key + pub fn get_wrong_private_key() -> SecretKey { + let private_key_bytes = + hex_literal::hex!("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1e"); + SecretKey::from_slice(&private_key_bytes).expect("Invalid private key") + } + + /// Get the signing private key + pub fn get_signing_private_key() -> SigningKey { + let private_key_bytes = + hex_literal::hex!("ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"); + let signing_key = + SigningKey::from_bytes(&private_key_bytes.into()).expect("Invalid private key"); + signing_key + } + + /// Get the plaintext for a seismic transaction + pub fn get_plaintext() -> Bytes { + Bytes::from_str("24a7f0b7000000000000000000000000000000000000000000000000000000000000000b") + .unwrap() + } + + /// Get a seismic transaction + pub fn get_seismic_tx() -> TxSeismic { + let ciphertext = get_ciphertext(); + TxSeismic { + chain_id: 1337, + nonce: 1, + gas_price: 20000000000, + gas_limit: 210000, + to: alloy_primitives::TxKind::Call( + Address::from_str("0x5fbdb2315678afecb367f032d93f642f64180aa3").unwrap(), + ), + value: U256::ZERO, + input: Bytes::copy_from_slice(&ciphertext), + seismic_elements: get_seismic_elements(), + authorization_list: vec![], + } + } + + /// Get the encoding of a signed seismic transaction + pub fn get_signed_seismic_tx_encoding() -> Vec<u8> { + let signed_tx = get_signed_seismic_tx(B256::ZERO); + let mut encoding = Vec::new(); + + signed_tx.encode_2718(&mut encoding); + encoding + } + + /// Sign a seismic transaction + pub fn sign_seismic_tx(tx: &TxSeismic) -> PrimitiveSignature { + let _signature = get_signing_private_key() + .clone() + .sign_prehash_recoverable(tx.signature_hash().as_slice()) + .expect("Failed to sign"); + + let recoverid = _signature.1; + let _signature = _signature.0; + + let signature = PrimitiveSignature::new( + U256::from_be_slice(_signature.r().to_bytes().as_slice()), + U256::from_be_slice(_signature.s().to_bytes().as_slice()), + recoverid.is_y_odd(), + ); + + signature + } + +}

diff --git reth/crates/seismic/node/tests/it/builder.rs seismic-reth/crates/seismic/node/tests/it/builder.rs new file mode 100644 index 0000000000000000000000000000000000000000..69d048636fc9ed4ccde03817ca1862bdebea7f05 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/it/builder.rs @@ -0,0 +1,37 @@ +//! Node builder setup tests. + +use reth_db::test_utils::create_test_rw_db; +use reth_node_api::{FullNodeComponents, NodeTypesWithDBAdapter}; +use reth_node_builder::{Node, NodeBuilder, NodeConfig}; +use reth_provider::providers::BlockchainProvider; +use reth_seismic_chainspec::SEISMIC_MAINNET; +use reth_seismic_node::node::SeismicNode; + +#[test] +fn test_basic_setup() { + // parse CLI -> config + let config = NodeConfig::new(SEISMIC_MAINNET.clone()); + let db = create_test_rw_db(); + let seismic_node = SeismicNode::default(); + let _builder = NodeBuilder::new(config) + .with_database(db) + .with_types_and_provider::<SeismicNode, BlockchainProvider<NodeTypesWithDBAdapter<SeismicNode, _>>>() + .with_components(seismic_node.components()) + .with_add_ons(seismic_node.add_ons()) + .on_component_initialized(move |ctx| { + let _provider = ctx.provider(); + Ok(()) + }) + .on_node_started(|_full_node| Ok(())) + .on_rpc_started(|_ctx, handles| { + let _client = handles.rpc.http_client(); + Ok(()) + }) + .extend_rpc_modules(|ctx| { + let _ = ctx.config(); + let _ = ctx.node().provider(); + + Ok(()) + }) + .check_launch(); +}

diff --git reth/crates/seismic/node/tests/it/exex.rs seismic-reth/crates/seismic/node/tests/it/exex.rs new file mode 100644 index 0000000000000000000000000000000000000000..856220300c2bb0a79a8a717e77a389e4ef85f595 --- /dev/null +++ seismic-reth/crates/seismic/node/tests/it/exex.rs @@ -0,0 +1,39 @@ +use futures::future; +use reth_db::test_utils::create_test_rw_db; +use reth_exex::ExExContext; +use reth_node_api::FullNodeComponents; +use reth_node_builder::{NodeBuilder, NodeConfig}; +use reth_node_ethereum::{node::EthereumAddOns, EthereumNode}; +use std::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; + +struct DummyExEx<Node: FullNodeComponents> { + _ctx: ExExContext<Node>, +} + +impl<Node> Future for DummyExEx<Node> +where + Node: FullNodeComponents, +{ + type Output = eyre::Result<()>; + + fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> { + Poll::Pending + } +} + +#[test] +fn basic_exex() { + let config = NodeConfig::test(); + let db = create_test_rw_db(); + let _builder = NodeBuilder::new(config) + .with_database(db) + .with_types::<EthereumNode>() + .with_components(EthereumNode::components()) + .with_add_ons(EthereumAddOns::default()) + .install_exex("dummy", move |ctx| future::ok(DummyExEx { _ctx: ctx })) + .check_launch(); +}

diff --git reth/crates/seismic/node/tests/it/main.rs seismic-reth/crates/seismic/node/tests/it/main.rs new file mode 100644 index 0000000000000000000000000000000000000000..0f85adda31d0847f57e5047648129f97e62cfbbc --- /dev/null +++ seismic-reth/crates/seismic/node/tests/it/main.rs @@ -0,0 +1,6 @@ +#![allow(missing_docs)] + +mod builder; +mod exex; + +const fn main() {}

diff --git reth/crates/seismic/rpc/Cargo.toml seismic-reth/crates/seismic/rpc/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..32e58d4500f5b7e20016aae7bf0ece31db3150a2 --- /dev/null +++ seismic-reth/crates/seismic/rpc/Cargo.toml @@ -0,0 +1,106 @@ +[package] +name = "reth-seismic-rpc" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +description = "Ethereum RPC implementation for seismic." + +[lints] +workspace = true + +[dependencies] + +# alloy +alloy-eips.workspace = true +alloy-primitives.workspace = true +alloy-rpc-types.workspace = true +alloy-rpc-types-eth.workspace = true +alloy-consensus.workspace = true +alloy-json-rpc.workspace = true +alloy-dyn-abi.workspace = true +alloy-sol-types.workspace = true + +# reth +reth-evm.workspace = true +reth-node-api.workspace = true +reth-node-builder.workspace = true +reth-primitives.workspace = true +reth-primitives-traits.workspace = true +reth-provider.workspace = true +reth-rpc.workspace = true +reth-rpc-convert.workspace = true +reth-rpc-eth-api.workspace = true +reth-rpc-eth-types.workspace = true +reth-rpc-layer.workspace = true +reth-rpc-server-types.workspace = true +reth-storage-api.workspace = true +reth-tasks = { workspace = true, features = ["rayon"] } +reth-tracing.workspace = true +reth-transaction-pool.workspace = true + +# revm +revm.workspace = true +revm-context.workspace = true + +# seismic-reth +reth-seismic-primitives = { workspace = true, features = [ + "reth-codec", + "serde-bincode-compat", +] } +seismic-enclave.workspace = true + +seismic-alloy-consensus.workspace = true +seismic-alloy-network.workspace = true +seismic-alloy-rpc-types = { workspace = true, features = ["serde", "k256"] } +reth-seismic-txpool.workspace = true +seismic-revm.workspace = true + +# async +tokio.workspace = true + +# rpc +jsonrpsee-types.workspace = true +jsonrpsee.workspace = true +futures.workspace = true + +# misc +eyre.workspace = true +serde.workspace = true +thiserror.workspace = true +tracing.workspace = true + +[dev-dependencies] +reth-seismic-chainspec.workspace = true +reth-consensus.workspace = true +reth-evm-ethereum.workspace = true +reth-ethereum-engine-primitives.workspace = true +reth-rpc-builder.workspace = true +reth-rpc-layer.workspace = true +reth-payload-builder.workspace = true +secp256k1.workspace = true +enr.workspace = true +k256.workspace = true +alloy-signer-local.workspace = true +reth-e2e-test-utils.workspace = true +reth-engine-primitives.workspace = true +reth-node-ethereum.workspace = true +reth-seismic-evm.workspace = true +reth-rpc-engine-api.workspace = true +alloy-rpc-types-engine.workspace = true + +[features] +default = ["client"] +timestamp-in-seconds = [ + "revm/timestamp-in-seconds", + "seismic-revm/timestamp-in-seconds", + "reth-seismic-primitives/timestamp-in-seconds", + "reth-seismic-chainspec/timestamp-in-seconds", +] +client = [ + "jsonrpsee/client", + "jsonrpsee/async-client", + "reth-rpc-eth-api/client", +]

diff --git reth/crates/seismic/rpc/src/error.rs seismic-reth/crates/seismic/rpc/src/error.rs new file mode 100644 index 0000000000000000000000000000000000000000..063974a4ab97e9ea522f331fbf25c87c1ddcd4d3 --- /dev/null +++ seismic-reth/crates/seismic/rpc/src/error.rs @@ -0,0 +1,106 @@ +//! Error types for the seismic rpc api. + +use std::convert::Infallible; + +use alloy_rpc_types_eth::BlockError; +use reth_provider::ProviderError; +use reth_rpc_eth_api::{AsEthApiError, EthTxEnvError, TransactionConversionError}; +use reth_rpc_eth_types::{error::api::FromEvmHalt, EthApiError}; +use reth_rpc_server_types::result::internal_rpc_err; +use revm::context_interface::result::EVMError; +use revm_context::result::HaltReason; + +#[derive(Debug, thiserror::Error)] +/// Seismic API error +pub enum SeismicEthApiError { + /// Eth error + #[error(transparent)] + Eth(#[from] EthApiError), + /// Enclave error + #[error("enclave error: {0}")] + EnclaveError(String), +} + +impl AsEthApiError for SeismicEthApiError { + fn as_err(&self) -> Option<&EthApiError> { + match self { + Self::Eth(err) => Some(err), + _ => None, + } + } +} + +impl From<SeismicEthApiError> for jsonrpsee::types::error::ErrorObject<'static> { + fn from(error: SeismicEthApiError) -> Self { + match error { + SeismicEthApiError::Eth(e) => e.into(), + SeismicEthApiError::EnclaveError(e) => internal_rpc_err(format!("enclave error: {e}")), + } + } +} + +impl From<TransactionConversionError> for SeismicEthApiError { + fn from(value: TransactionConversionError) -> Self { + Self::Eth(EthApiError::from(value)) + } +} + +impl From<EthTxEnvError> for SeismicEthApiError { + fn from(value: EthTxEnvError) -> Self { + Self::Eth(EthApiError::from(value)) + } +} + +impl From<ProviderError> for SeismicEthApiError { + fn from(value: ProviderError) -> Self { + Self::Eth(EthApiError::from(value)) + } +} + +impl From<BlockError> for SeismicEthApiError { + fn from(value: BlockError) -> Self { + Self::Eth(EthApiError::from(value)) + } +} + +impl From<Infallible> for SeismicEthApiError { + fn from(value: Infallible) -> Self { + match value {} + } +} + +impl From<EVMError<ProviderError>> for SeismicEthApiError { + fn from(error: EVMError<ProviderError>) -> Self { + Self::Eth(EthApiError::from(error)) + } +} + +// Implementation for revm halt reason (base case) +impl From<HaltReason> for SeismicEthApiError { + fn from(halt: HaltReason) -> Self { + Self::Eth(EthApiError::other(internal_rpc_err(format!("EVM halted: {halt:?}")))) + } +} + +// FromEvmHalt implementation for base revm halt reason +impl FromEvmHalt<HaltReason> for SeismicEthApiError { + fn from_evm_halt(halt: HaltReason, gas_limit: u64) -> Self { + // Delegate to the existing From implementation for the halt reason + // and use the gas limit info if needed + Self::Eth(EthApiError::other(internal_rpc_err(format!( + "EVM halted: {halt:?} (gas limit: {gas_limit})" + )))) + } +} + +#[cfg(test)] +mod tests { + use crate::error::SeismicEthApiError; + + #[test] + fn enclave_error_message() { + let err: jsonrpsee::types::error::ErrorObject<'static> = + SeismicEthApiError::EnclaveError("test".to_string()).into(); + assert_eq!(err.message(), "enclave error: test"); + } +}

diff --git reth/crates/seismic/rpc/src/eth/api.rs seismic-reth/crates/seismic/rpc/src/eth/api.rs new file mode 100644 index 0000000000000000000000000000000000000000..8034a505b946c53261bb40d7ae1ccfea3aa27ec5 --- /dev/null +++ seismic-reth/crates/seismic/rpc/src/eth/api.rs @@ -0,0 +1,37 @@ +//! Seismic extension of API traits + +use reth_rpc_eth_api::{ + helpers::{EthApiSpec, EthBlocks, EthCall, EthFees, EthState, LoadReceipt, Trace}, + FullEthApiTypes, +}; + +use super::ext::SeismicTransaction; + +/// Helper trait to unify all `eth` rpc server building block traits, for simplicity. +/// +/// This trait is automatically implemented for any type that implements all the `Eth` traits. +pub trait FullSeismicApi: + FullEthApiTypes + + EthApiSpec + + SeismicTransaction + + EthBlocks + + EthState + + EthCall + + EthFees + + Trace + + LoadReceipt +{ +} + +impl<T> FullSeismicApi for T where + T: FullEthApiTypes + + EthApiSpec + + SeismicTransaction + + EthBlocks + + EthState + + EthCall + + EthFees + + Trace + + LoadReceipt +{ +}

diff --git reth/crates/seismic/rpc/src/eth/block.rs seismic-reth/crates/seismic/rpc/src/eth/block.rs new file mode 100644 index 0000000000000000000000000000000000000000..d926a9113b29fa235db4ea7fd1b5ab70b6d3a092 --- /dev/null +++ seismic-reth/crates/seismic/rpc/src/eth/block.rs @@ -0,0 +1,23 @@ +//! Loads and formats Seismic block RPC response. + +use crate::{SeismicEthApi, SeismicEthApiError}; +use reth_rpc_eth_api::{ + helpers::{EthBlocks, LoadBlock}, + FromEvmError, RpcConvert, RpcNodeCore, +}; + +impl<N, Rpc> EthBlocks for SeismicEthApi<N, Rpc> +where + N: RpcNodeCore, + SeismicEthApiError: FromEvmError<N::Evm>, + Rpc: RpcConvert<Primitives = N::Primitives, Error = SeismicEthApiError>, +{ +} + +impl<N, Rpc> LoadBlock for SeismicEthApi<N, Rpc> +where + N: RpcNodeCore, + SeismicEthApiError: FromEvmError<N::Evm>, + Rpc: RpcConvert<Primitives = N::Primitives, Error = SeismicEthApiError>, +{ +}

diff --git reth/crates/seismic/rpc/src/eth/call.rs seismic-reth/crates/seismic/rpc/src/eth/call.rs new file mode 100644 index 0000000000000000000000000000000000000000..05f54370539f9a0ae54225923e7bb97971c007f3 --- /dev/null +++ seismic-reth/crates/seismic/rpc/src/eth/call.rs @@ -0,0 +1,180 @@ +use crate::{SeismicEthApi, SeismicEthApiError}; +use alloy_consensus::transaction::Either; +use alloy_eips::eip7702::{RecoveredAuthorization, SignedAuthorization}; +use alloy_primitives::{TxKind, U256}; +use alloy_rpc_types_eth::transaction::TransactionRequest; +use reth_evm::{EvmEnv, SpecFor, TxEnvFor}; +use reth_rpc_eth_api::{ + helpers::{estimate::EstimateCall, Call, EthCall}, + CallFees, EthTxEnvError, FromEthApiError, FromEvmError, IntoEthApiError, RpcConvert, + RpcNodeCore, RpcTxReq, +}; +use reth_rpc_eth_types::{EthApiError, RpcInvalidTransactionError}; +use revm::{context::TxEnv, context_interface::Block, Database}; +use seismic_alloy_consensus::SeismicTxType; +use seismic_revm::{self, SeismicTransaction}; + +impl<N, Rpc> EthCall for SeismicEthApi<N, Rpc> +where + N: RpcNodeCore, + SeismicEthApiError: FromEvmError<N::Evm>, + TxEnvFor<N::Evm>: From<SeismicTransaction<TxEnv>>, + SeismicTransaction<TxEnv>: Into<TxEnvFor<N::Evm>>, + Rpc: RpcConvert< + Primitives = N::Primitives, + Error = SeismicEthApiError, + TxEnv = TxEnvFor<N::Evm>, + Spec = SpecFor<N::Evm>, + >, +{ +} + +impl<N, Rpc> EstimateCall for SeismicEthApi<N, Rpc> +where + Self: Call, + Self::Error: From<EthApiError>, + N: RpcNodeCore, + Rpc: RpcConvert< + Primitives = N::Primitives, + Error = SeismicEthApiError, + TxEnv = TxEnvFor<N::Evm>, + Spec = SpecFor<N::Evm>, + >, +{ +} + +impl<N, Rpc> Call for SeismicEthApi<N, Rpc> +where + N: RpcNodeCore, + SeismicEthApiError: FromEvmError<N::Evm>, + TxEnvFor<N::Evm>: From<SeismicTransaction<TxEnv>>, + SeismicTransaction<TxEnv>: Into<TxEnvFor<N::Evm>>, + Rpc: RpcConvert< + Primitives = N::Primitives, + Error = SeismicEthApiError, + TxEnv = TxEnvFor<N::Evm>, + Spec = SpecFor<N::Evm>, + >, +{ + #[inline] + fn call_gas_limit(&self) -> u64 { + self.inner.gas_cap() + } + + #[inline] + fn max_simulate_blocks(&self) -> u64 { + self.inner.max_simulate_blocks() + } + + fn create_txn_env( + &self, + evm_env: &EvmEnv<SpecFor<Self::Evm>>, + request: RpcTxReq<Rpc::Network>, + mut db: impl Database<Error: Into<EthApiError>>, + ) -> Result<TxEnvFor<N::Evm>, Self::Error> { + // Convert network request to concrete TransactionRequest + let request: &TransactionRequest = request.as_ref(); + + // Ensure that if versioned hashes are set, they're not empty + if request.blob_versioned_hashes.as_ref().is_some_and(|hashes| hashes.is_empty()) { + return Err(RpcInvalidTransactionError::BlobTransactionMissingBlobHashes.into_eth_err()); + } + + let tx_type = if request.authorization_list.is_some() { + SeismicTxType::Eip7702 + } else if request.max_fee_per_gas.is_some() || request.max_priority_fee_per_gas.is_some() { + SeismicTxType::Eip1559 + } else if request.access_list.is_some() { + SeismicTxType::Eip2930 + } else { + SeismicTxType::Seismic + } as u8; + + let TransactionRequest { + from, + to, + gas_price, + max_fee_per_gas, + max_priority_fee_per_gas, + gas, + value, + input, + nonce, + access_list, + chain_id, + blob_versioned_hashes, + max_fee_per_blob_gas, + authorization_list, + transaction_type: _, + sidecar: _, + } = request; + + let CallFees { max_priority_fee_per_gas, gas_price, max_fee_per_blob_gas } = + CallFees::ensure_fees( + gas_price.map(U256::from), + max_fee_per_gas.map(U256::from), + max_priority_fee_per_gas.map(U256::from), + U256::from(evm_env.block_env.basefee), + blob_versioned_hashes.as_deref(), + max_fee_per_blob_gas.map(U256::from), + evm_env.block_env.blob_gasprice().map(U256::from), + ) + .map_err(EthTxEnvError::CallFees)?; + + let gas_limit = gas.unwrap_or( + // Use maximum allowed gas limit. The reason for this + // is that both Erigon and Geth use pre-configured gas cap even if + // it's possible to derive the gas limit from the block: + // <https://github.com/ledgerwatch/erigon/blob/eae2d9a79cb70dbe30b3a6b79c436872e4605458/cmd/rpcdaemon/commands/trace_adhoc.go#L956 + // https://github.com/ledgerwatch/erigon/blob/eae2d9a79cb70dbe30b3a6b79c436872e4605458/eth/ethconfig/config.go#L94> + evm_env.block_env.gas_limit, + ); + + let chain_id = chain_id.unwrap_or(evm_env.cfg_env.chain_id); + + let caller = from.unwrap_or_default(); + + let nonce = if let Some(nonce) = nonce { + *nonce + } else { + db.basic(caller).map_err(Into::into)?.map(|acc| acc.nonce).unwrap_or_default() + }; + + let authorization_list: Vec<Either<SignedAuthorization, RecoveredAuthorization>> = + authorization_list + .clone() + .unwrap_or_default() + .iter() + .map(|auth| Either::Left(auth.clone())) + .collect(); + let env = TxEnv { + tx_type, + gas_limit, + nonce, + caller, + gas_price: gas_price.saturating_to(), + gas_priority_fee: max_priority_fee_per_gas.map(|v| v.saturating_to()), + kind: to.unwrap_or(TxKind::Create), + value: value.unwrap_or_default(), + data: input + .clone() + .try_into_unique_input() + .map_err(Self::Error::from_eth_err)? + .unwrap_or_default(), + chain_id: Some(chain_id), + access_list: access_list.clone().unwrap_or_default(), + // EIP-4844 fields + blob_hashes: blob_versioned_hashes.clone().unwrap_or_default(), + max_fee_per_blob_gas: max_fee_per_blob_gas + .map(|v| v.saturating_to()) + .unwrap_or_default(), + // EIP-7702 fields + authorization_list, + }; + + tracing::debug!("reth-seismic-rpc::eth create_txn_env {:?}", env); + + Ok(SeismicTransaction { base: env, tx_hash: Default::default(), decryption_failed: false } + .into()) + } +}

diff --git reth/crates/seismic/rpc/src/eth/ext.rs seismic-reth/crates/seismic/rpc/src/eth/ext.rs new file mode 100644 index 0000000000000000000000000000000000000000..959f5d543d873bb87afed453da85632a3a2138ec --- /dev/null +++ seismic-reth/crates/seismic/rpc/src/eth/ext.rs @@ -0,0 +1,353 @@ +//! seismic implementation of eth api and its extensions +//! +//! Overrides the eth_ namespace to be compatible with seismic specific types +//! Most endpoints handle transaction decrytpion before passing to the inner eth api +//! For `eth_sendRawTransaction`, we directly call the inner eth api without decryption +//! See that function's docs for more details + +use super::api::FullSeismicApi; +use crate::utils::{ + convert_seismic_call_to_tx_request, parse_request_sender, signed_read_to_plaintext_tx, +}; +use alloy_dyn_abi::TypedData; +use alloy_json_rpc::RpcObject; +use alloy_primitives::{Address, Bytes, B256, U256}; +use alloy_rpc_types::{ + state::{EvmOverrides, StateOverride}, + BlockId, BlockOverrides, TransactionRequest, +}; +use alloy_rpc_types_eth::simulate::{ + SimBlock as EthSimBlock, SimulatePayload as EthSimulatePayload, SimulatedBlock, +}; +use futures::Future; +use jsonrpsee::{ + core::{async_trait, RpcResult}, + proc_macros::rpc, +}; +use reth_rpc_eth_api::{ + helpers::{EthCall, EthTransactions}, + RpcBlock, RpcTypes, +}; +use reth_rpc_eth_types::EthApiError; +use reth_tracing::tracing::*; +use seismic_alloy_consensus::{InputDecryptionElements, TxSeismicMetadata, TypedDataRequest}; +use seismic_alloy_rpc_types::{ + SeismicCallRequest, SeismicRawTxRequest, SeismicTransactionRequest, + SimBlock as SeismicSimBlock, SimulatePayload as SeismicSimulatePayload, +}; +use seismic_enclave::{secp256k1::PublicKey, GetPurposeKeysResponse}; +use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; + +/// trait interface for a custom rpc namespace: `seismic` +/// +/// This defines an additional namespace where all methods are configured as trait functions. +#[cfg_attr(not(feature = "client"), rpc(server, namespace = "seismic"))] +#[cfg_attr(feature = "client", rpc(server, client, namespace = "seismic"))] +pub trait SeismicApi { + /// Returns the network public key + #[method(name = "getTeePublicKey")] + async fn get_tee_public_key(&self) -> RpcResult<PublicKey>; +} + +/// Implementation of the seismic rpc api +#[derive(Debug, Clone)] +pub struct SeismicApi { + purpose_keys: GetPurposeKeysResponse, +} + +impl SeismicApi { + /// Creates a new seismic api instance + pub const fn new(purpose_keys: GetPurposeKeysResponse) -> Self { + Self { purpose_keys } + } +} + +#[async_trait] +impl SeismicApiServer for SeismicApi { + async fn get_tee_public_key(&self) -> RpcResult<PublicKey> { + trace!(target: "rpc::seismic", "Serving seismic_getTeePublicKey"); + Ok(self.purpose_keys.tx_io_pk) + } +} + +/// Localhost with port 0 so a free port is used. +pub const fn test_address() -> SocketAddr { + SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0)) +} + +/// Extension trait for `EthTransactions` to add custom transaction sending functionalities. +pub trait SeismicTransaction: EthTransactions { + /// Decodes, signs (if necessary via an internal signer or enclave), + /// and submits a typed data transaction to the pool. + /// Returns the hash of the transaction. + fn send_typed_data_transaction( + &self, + tx_request: TypedDataRequest, + ) -> impl Future<Output = Result<B256, Self::Error>> + Send; +} + +/// Seismic `eth_` RPC namespace overrides. +#[cfg_attr(not(feature = "client"), rpc(server, namespace = "eth"))] +#[cfg_attr(feature = "client", rpc(server, client, namespace = "eth"))] +pub trait EthApiOverride<B: RpcObject> { + /// Returns the account and storage values of the specified account including the Merkle-proof. + /// This call can be used to verify that the data you are pulling from is not tampered with. + #[method(name = "signTypedData_v4")] + async fn sign_typed_data_v4(&self, address: Address, data: TypedData) -> RpcResult<String>; + + /// `eth_simulateV1` executes an arbitrary number of transactions on top of the requested state. + /// The transactions are packed into individual blocks. Overrides can be provided. + #[method(name = "simulateV1")] + async fn simulate_v1( + &self, + opts: SeismicSimulatePayload<SeismicCallRequest>, + block_number: Option<BlockId>, + ) -> RpcResult<Vec<SimulatedBlock<B>>>; + + /// Executes a new message call immediately without creating a transaction on the block chain. + #[method(name = "call")] + async fn call( + &self, + request: SeismicCallRequest, + block_number: Option<BlockId>, + state_overrides: Option<StateOverride>, + block_overrides: Option<Box<BlockOverrides>>, + ) -> RpcResult<Bytes>; + + /// Sends signed transaction, returning its hash. + #[method(name = "sendRawTransaction")] + async fn send_raw_transaction(&self, bytes: SeismicRawTxRequest) -> RpcResult<B256>; + + /// Generates and returns an estimate of how much gas is necessary to allow the transaction to + /// complete. + #[method(name = "estimateGas")] + async fn estimate_gas( + &self, + request: SeismicCallRequest, + block_number: Option<BlockId>, + state_override: Option<StateOverride>, + ) -> RpcResult<U256>; +} + +/// Implementation of the `eth_` namespace override +#[derive(Debug, Clone)] +pub struct EthApiExt<Eth> { + eth_api: Eth, + purpose_keys: GetPurposeKeysResponse, +} + +impl<Eth> EthApiExt<Eth> { + /// Create a new `EthApiExt` module. + pub const fn new(eth_api: Eth, purpose_keys: GetPurposeKeysResponse) -> Self { + Self { eth_api, purpose_keys } + } + + /// Build transaction metadata for encryption/decryption. + /// Returns an error if required fields are missing. + fn build_metadata( + request: &SeismicTransactionRequest, + sender: Address, + ) -> Result<TxSeismicMetadata, EthApiError> { + request.metadata(sender).map_err(|e| { + EthApiError::Other(Box::new(jsonrpsee_types::ErrorObject::owned( + -32602, + format!("Failed to build seismic metadata: {}", e), + None::<String>, + ))) + }) + } +} + +#[async_trait] +impl<Eth> EthApiOverrideServer<RpcBlock<Eth::NetworkTypes>> for EthApiExt<Eth> +where + Eth: FullSeismicApi + Send + Sync + 'static, + Eth::Error: Send + Sync + 'static, + jsonrpsee_types::error::ErrorObject<'static>: From<Eth::Error>, + <Eth::NetworkTypes as RpcTypes>::TransactionRequest: + From<TransactionRequest> + AsRef<TransactionRequest> + Send + Sync + 'static, +{ + /// Handler for: `eth_signTypedData_v4` + /// + /// TODO: determine if this should be removed, seems the same as eth functionality + async fn sign_typed_data_v4(&self, from: Address, data: TypedData) -> RpcResult<String> { + debug!(target: "reth-seismic-rpc::eth", "Serving seismic eth_signTypedData_v4 extension"); + let signature = EthTransactions::sign_typed_data(&self.eth_api, &data, from) + .map_err(|err| err.into())?; + let signature = alloy_primitives::hex::encode(signature); + Ok(format!("0x{signature}")) + } + + /// Handler for: `eth_simulateV1` + async fn simulate_v1( + &self, + payload: SeismicSimulatePayload<SeismicCallRequest>, + block_number: Option<BlockId>, + ) -> RpcResult<Vec<SimulatedBlock<RpcBlock<Eth::NetworkTypes>>>> { + debug!(target: "reth-seismic-rpc::eth", "Serving seismic eth_simulateV1 extension"); + + let seismic_sim_blocks: Vec<SeismicSimBlock<SeismicCallRequest>> = + payload.block_state_calls.clone(); + + // Recover EthSimBlocks from the SeismicSimulatePayload<SeismicCallRequest> + let mut eth_simulated_blocks: Vec< + EthSimBlock<<Eth::NetworkTypes as RpcTypes>::TransactionRequest>, + > = Vec::with_capacity(payload.block_state_calls.len()); + for block in payload.block_state_calls { + let SeismicSimBlock { block_overrides, state_overrides, calls } = block; + let mut prepared_calls = Vec::with_capacity(calls.len()); + + for call in calls { + let tx_req = convert_seismic_call_to_tx_request(call)?; + let plaintext_tx_req = + signed_read_to_plaintext_tx(tx_req, &self.purpose_keys.tx_io_sk)?; + let tx_request: TransactionRequest = plaintext_tx_req.inner; + prepared_calls.push(tx_request.into()); + } + + let prepared_block = + EthSimBlock { block_overrides, state_overrides, calls: prepared_calls }; + + eth_simulated_blocks.push(prepared_block); + } + + // Call Eth simulate_v1, which only takes EthSimPayload/EthSimBlock + let mut result = EthCall::simulate_v1( + &self.eth_api, + EthSimulatePayload { + block_state_calls: eth_simulated_blocks.clone(), + trace_transfers: payload.trace_transfers, + validation: payload.validation, + return_full_transactions: payload.return_full_transactions, + }, + block_number, + ) + .await?; + + // Convert Eth Blocks back to Seismic blocks + for (block, result) in seismic_sim_blocks.iter().zip(result.iter_mut()) { + let SeismicSimBlock::<SeismicCallRequest> { calls, .. } = block; + let SimulatedBlock { calls: call_results, .. } = result; + + for (call_result, call) in call_results.iter_mut().zip(calls.iter()) { + let (seismic_tx_request, signed_read) = + convert_seismic_call_to_tx_request(call.clone())?; + if signed_read { + // if there are seismic elements, encrypt the output + let sender = parse_request_sender(&seismic_tx_request)?; + let metadata = Self::build_metadata(&seismic_tx_request, sender)?; + let encrypted_output = metadata + .encrypt(&self.purpose_keys.tx_io_sk, &call_result.return_data) + .map_err(|e| ext_encryption_error(e.to_string()))?; + call_result.return_data = encrypted_output; + } + } + } + + Ok(result) + } + + /// Handler for: `eth_call` + async fn call( + &self, + request: SeismicCallRequest, + block_number: Option<BlockId>, + state_overrides: Option<StateOverride>, + block_overrides: Option<Box<BlockOverrides>>, + ) -> RpcResult<Bytes> { + debug!(target: "reth-seismic-rpc::eth", ?request, ?block_number, ?state_overrides, ?block_overrides, "Serving seismic eth_call extension"); + + // process different CallRequest types + let (seismic_tx_request, signed_read) = convert_seismic_call_to_tx_request(request)?; + let plaintext_tx_req = signed_read_to_plaintext_tx( + (seismic_tx_request.clone(), signed_read), + &self.purpose_keys.tx_io_sk, + )?; + + // call inner + let result = EthCall::call( + &self.eth_api, + plaintext_tx_req.inner.into(), + block_number, + EvmOverrides::new(state_overrides, block_overrides), + ) + .await?; + + // encrypt result - only for signed reads with seismic elements + if signed_read { + if let Some(seismic_elements) = seismic_tx_request.seismic_elements { + let sender = parse_request_sender(&seismic_tx_request)?; + let metadata = Self::build_metadata(&seismic_tx_request, sender)?; + return Ok(seismic_elements + .encrypt(&self.purpose_keys.tx_io_sk, &result, &metadata) + .map_err(|e| ext_encryption_error(e.to_string()))?); + } + } + + Ok(result) + } + + /// Handler for: `eth_sendRawTransaction` + /// + /// Directly calls the inner eth api without decryption + /// We do this so that it is encrypted in the tx pool, so it is encrypted in blocks + /// decryption during execution is handled by the [`SeismicBlockExecutor`] + async fn send_raw_transaction(&self, tx: SeismicRawTxRequest) -> RpcResult<B256> { + debug!(target: "reth-seismic-rpc::eth", ?tx, "Serving overridden eth_sendRawTransaction extension"); + match tx { + SeismicRawTxRequest::Bytes(bytes) => { + Ok(EthTransactions::send_raw_transaction(&self.eth_api, bytes).await?) + } + SeismicRawTxRequest::TypedData(typed_data) => { + Ok(SeismicTransaction::send_typed_data_transaction(&self.eth_api, typed_data) + .await?) + } + } + } + + async fn estimate_gas( + &self, + request: SeismicCallRequest, + block_number: Option<BlockId>, + state_override: Option<StateOverride>, + ) -> RpcResult<U256> { + debug!(target: "reth-seismic-rpc::eth", ?request, ?block_number, ?state_override, "serving seismic eth_estimateGas extension"); + + // Same sanitization as eth_call: unsigned requests have `from`, + // gas/value fields, and seismic_elements cleared to prevent caller + // spoofing that could leak private state. Signed requests (TypedData/Bytes) + // authenticate the sender cryptographically and are processed normally. + let (seismic_tx_request, signed_read) = convert_seismic_call_to_tx_request(request)?; + let decrypted_req = signed_read_to_plaintext_tx( + (seismic_tx_request, signed_read), + &self.purpose_keys.tx_io_sk, + )?; + + // call inner + Ok(EthCall::estimate_gas_at( + &self.eth_api, + decrypted_req.inner.into(), + block_number.unwrap_or_default(), + state_override, + ) + .await?) + } +} + +/// Creates an [`EthApiError`] that says that seismic decryption failed +pub fn ext_decryption_error(e_str: String) -> EthApiError { + EthApiError::Other(Box::new(jsonrpsee_types::ErrorObject::owned( + -32000, // TODO: pick a better error code? + "Error Decrypting in Seismic EthApiExt", + Some(e_str), + ))) +} + +/// Creates an [`EthApiError`] that says that seismic encryption failed +pub fn ext_encryption_error(e_str: String) -> EthApiError { + EthApiError::Other(Box::new(jsonrpsee_types::ErrorObject::owned( + -32000, // TODO: pick a better error code? + "Error Encrypting in Seismic EthApiExt", + Some(e_str), + ))) +}