feat: eth_simulateV1 support

[klkvr]

ref #8281

Adds support for eth_simulateV1, primary using geth implementation as reference (ethereum/go-ethereum#27720).

For now it does not support moving precompiles, and does not calculate resulted block hashes correctly. Precompiles will be added later as it would be a pretty invasive change now.

And regarding block hashes, I am wondering if we have a way to calculate state root for in-memory state? would appreciate some pointers here

Marking as draft as I am still testing it and it's patched to alloy branch with small serde fixes

[mattsse]

I am wondering if we have a way to calculate state root for in-memory state?

this should be possible, right @rkrasiuk

reth/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs

Lines 407 to 417 in 026bfcc

	let hashed_state = HashedPostState::from_bundle_state(&execution_outcome.state().state);
	let receipts_root = self.receipts_root(&block_env, &execution_outcome, block_number);
	let logs_bloom =
	execution_outcome.block_logs_bloom(block_number).expect("Block is present");
	// calculate the state root
	let state_provider = &db.database;
	let state_root =
	state_provider.state_root(hashed_state).map_err(Self::Error::from_eth_err)?;

@rkrasiuk we probably need some help navigating this API, or if this can be used with the CacheDB ?

[rkrasiuk]

it is possible, all you need is to construct the HashedPostState from state changes. we already do that here

reth/crates/rpc/rpc/src/debug.rs

Lines 640 to 668 in e585436

	for (address, account) in db.cache.accounts {
	let hashed_address = keccak256(address);
	hashed_state.accounts.insert(
	hashed_address,
	account.account.as_ref().map(|a| a.info.clone().into()),
	);
	let storage = hashed_state
	.storages
	.entry(hashed_address)
	.or_insert_with(|| HashedStorage::new(account.status.was_destroyed()));
	if let Some(account) = account.account {
	if include_preimages {
	state_preimages
	.insert(hashed_address, alloy_rlp::encode(address).into());
	}
	for (slot, value) in account.storage {
	let slot = B256::from(slot);
	let hashed_slot = keccak256(slot);
	storage.storage.insert(hashed_slot, value);
	if include_preimages {
	state_preimages.insert(hashed_slot, alloy_rlp::encode(slot).into());
	}
	}
	}
	}

one thing that's unclear to me is whether the resulting state root should include state overrides that were passed as inputs

[klkvr]

one thing that's unclear to me is whether the resulting state root should include state overrides that were passed as inputs

I think it should, given that we persist those between blocks and there might be an edge case when we can't really distinguish between slot that was just overriden and the case when it was overriden, then changed during execution and updated to the same value

[mattsse]

this endpoint does a lot -.-

this looks pretty good, the execution logic seems right to me
there are likely a few things missing but we should try to get this in and then once we have a way to get reference data write some tests or fix things

[mattsse]

why does this not return B, because this response should include txs with additional fields?

[klkvr]

our primivie -> rpc conversions return such Block so I've just reused it

reth/crates/rpc/rpc-types-compat/src/block.rs

Lines 18 to 23 in 875cee2

	pub fn from_block(
	block: BlockWithSenders,
	total_difficulty: U256,
	kind: BlockTransactionsKind,
	block_hash: Option<B256>,
	) -> Result<Block<WithOtherFields<Transaction>>, BlockError> {

I think this generic type should be same to the network's block response in general

[mattsse]

pretty cool.

what's still missing here? the moved precompiles? what else?
could you please add these as todos to the issue?

[klkvr]

what's still missing here? the moved precompiles? what else?

yeah, only moving precompiles I believe, will track