Skip to content

Commit deb58b3

Browse files
OppenOppen
committed
fix: nearly all write APIs async
Missing: - Actual asynchronous implementations - Dedicated task for sync to avoid blocking requests - Read APIs
1 parent 67ba2b3 commit deb58b3

37 files changed

Lines changed: 411 additions & 375 deletions

‎Cargo.lock‎

Lines changed: 3 additions & 2 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Cargo.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ ethrex-prover = { path = "./crates/l2/prover" }
5151
tracing = { version = "0.1", features = ["log"] }
5252
tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
5353

54+
async-trait = "0.1.88"
5455
ethereum-types = { version = "0.15.1", features = ["serialize"] }
5556
serde = { version = "1.0.203", features = ["derive"] }
5657
serde_json = "1.0.117"

‎cmd/ef_tests/blockchain/test_runner.rs‎

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -8,17 +8,14 @@ use ethrex_common::types::{
88
use ethrex_rlp::decode::RLPDecode;
99
use ethrex_storage::{EngineType, Store};
1010

11-
use tokio::runtime::Runtime;
12-
13-
pub fn run_ef_test(test_key: &str, test: &TestUnit) {
11+
pub async fn run_ef_test(test_key: &str, test: &TestUnit) {
1412
// check that the decoded genesis block header matches the deserialized one
1513
let genesis_rlp = test.genesis_rlp.clone();
1614
let decoded_block = CoreBlock::decode(&genesis_rlp).unwrap();
1715
let genesis_block_header = CoreBlockHeader::from(test.genesis_block_header.clone());
1816
assert_eq!(decoded_block.header, genesis_block_header);
1917

20-
let store = build_store_for_test(test);
21-
let rt = Runtime::new().unwrap();
18+
let store = build_store_for_test(test).await;
2219

2320
// Check world_state
2421
check_prestate_against_db(test_key, test, &store);
@@ -36,7 +33,7 @@ pub fn run_ef_test(test_key: &str, test: &TestUnit) {
3633
let hash = block.hash();
3734

3835
// Attempt to add the block as the head of the chain
39-
let chain_result = rt.block_on(blockchain.add_block(block));
36+
let chain_result = blockchain.add_block(block).await;
4037
match chain_result {
4138
Err(error) => {
4239
assert!(
@@ -53,7 +50,7 @@ pub fn run_ef_test(test_key: &str, test: &TestUnit) {
5350
test_key,
5451
block_fixture.expect_exception.clone().unwrap()
5552
);
56-
apply_fork_choice(&store, hash, hash, hash).unwrap();
53+
apply_fork_choice(&store, hash, hash, hash).await.unwrap();
5754
}
5855
}
5956
}
@@ -85,12 +82,13 @@ pub fn parse_test_file(path: &Path) -> HashMap<String, TestUnit> {
8582
}
8683

8784
/// Creats a new in-memory store and adds the genesis state
88-
pub fn build_store_for_test(test: &TestUnit) -> Store {
85+
pub async fn build_store_for_test(test: &TestUnit) -> Store {
8986
let store =
9087
Store::new("store.db", EngineType::InMemory).expect("Failed to build DB for testing");
9188
let genesis = test.get_genesis();
9289
store
9390
.add_initial_state(genesis)
91+
.await
9492
.expect("Failed to add genesis state");
9593
store
9694
}

‎cmd/ef_tests/state/runner/levm_runner.rs‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ use ethrex_vm::backends;
1919
use keccak_hash::keccak;
2020
use std::{collections::HashMap, sync::Arc};
2121

22-
pub fn run_ef_test(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
22+
pub async fn run_ef_test(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
2323
// There are some tests that don't have a hash, unwrap will panic
2424
let hash = test
2525
._info
@@ -36,7 +36,7 @@ pub fn run_ef_test(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
3636
if !test.post.has_vector_for_fork(vector, *fork) {
3737
continue;
3838
}
39-
match run_ef_test_tx(vector, test, fork) {
39+
match run_ef_test_tx(vector, test, fork).await {
4040
Ok(_) => continue,
4141
Err(EFTestRunnerError::VMInitializationFailed(reason)) => {
4242
ef_test_report_fork.register_vm_initialization_failure(reason, *vector);
@@ -74,24 +74,24 @@ pub fn run_ef_test(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
7474
Ok(ef_test_report)
7575
}
7676

77-
pub fn run_ef_test_tx(
77+
pub async fn run_ef_test_tx(
7878
vector: &TestVector,
7979
test: &EFTest,
8080
fork: &Fork,
8181
) -> Result<(), EFTestRunnerError> {
82-
let mut levm = prepare_vm_for_tx(vector, test, fork)?;
82+
let mut levm = prepare_vm_for_tx(vector, test, fork).await?;
8383
ensure_pre_state(&levm, test)?;
8484
let levm_execution_result = levm.execute();
85-
ensure_post_state(&levm_execution_result, vector, test, fork)?;
85+
ensure_post_state(&levm_execution_result, vector, test, fork).await?;
8686
Ok(())
8787
}
8888

89-
pub fn prepare_vm_for_tx(
89+
pub async fn prepare_vm_for_tx(
9090
vector: &TestVector,
9191
test: &EFTest,
9292
fork: &Fork,
9393
) -> Result<VM, EFTestRunnerError> {
94-
let db = Arc::new(utils::load_initial_state_levm(test));
94+
let db = Arc::new(utils::load_initial_state_levm(test).await);
9595

9696
let tx = test
9797
.transactions
@@ -273,7 +273,7 @@ fn exception_is_expected(
273273
})
274274
}
275275

276-
pub fn ensure_post_state(
276+
pub async fn ensure_post_state(
277277
levm_execution_result: &Result<ExecutionReport, VMError>,
278278
vector: &TestVector,
279279
test: &EFTest,
@@ -308,7 +308,7 @@ pub fn ensure_post_state(
308308
}
309309
// Execution result was successful and no exception was expected.
310310
None => {
311-
let store_wrapper = utils::load_initial_state_levm(test);
311+
let store_wrapper = utils::load_initial_state_levm(test).await;
312312
let block_header = store_wrapper
313313
.store
314314
.get_block_header_by_hash(store_wrapper.block_hash)
@@ -332,7 +332,7 @@ pub fn ensure_post_state(
332332
.to_owned(),
333333
)
334334
})?;
335-
let pos_state_root = post_state_root(&levm_account_updates, test);
335+
let pos_state_root = post_state_root(&levm_account_updates, test).await;
336336
let expected_post_state_root_hash =
337337
test.post.vector_post_value(vector, *fork).hash;
338338
if expected_post_state_root_hash != pos_state_root {
@@ -386,12 +386,13 @@ pub fn ensure_post_state(
386386
Ok(())
387387
}
388388

389-
pub fn post_state_root(account_updates: &[AccountUpdate], test: &EFTest) -> H256 {
390-
let (initial_state, block_hash) = utils::load_initial_state(test);
389+
pub async fn post_state_root(account_updates: &[AccountUpdate], test: &EFTest) -> H256 {
390+
let (initial_state, block_hash) = utils::load_initial_state(test).await;
391391
initial_state
392392
.database()
393393
.unwrap()
394394
.apply_account_updates(block_hash, account_updates)
395+
.await
395396
.unwrap()
396397
.unwrap()
397398
}

‎cmd/ef_tests/state/runner/mod.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -63,27 +63,27 @@ pub struct EFTestRunnerOptions {
6363
pub revm: bool,
6464
}
6565

66-
pub fn run_ef_tests(
66+
pub async fn run_ef_tests(
6767
ef_tests: Vec<EFTest>,
6868
opts: &EFTestRunnerOptions,
6969
) -> Result<(), EFTestRunnerError> {
7070
let mut reports = report::load()?;
7171
if reports.is_empty() {
7272
if opts.revm {
73-
run_with_revm(&mut reports, &ef_tests, opts)?;
73+
run_with_revm(&mut reports, &ef_tests, opts).await?;
7474
return Ok(());
7575
} else {
76-
run_with_levm(&mut reports, &ef_tests, opts)?;
76+
run_with_levm(&mut reports, &ef_tests, opts).await?;
7777
}
7878
}
7979
if opts.summary {
8080
return Ok(());
8181
}
82-
re_run_with_revm(&mut reports, &ef_tests, opts)?;
82+
re_run_with_revm(&mut reports, &ef_tests, opts).await?;
8383
write_report(&reports)
8484
}
8585

86-
fn run_with_levm(
86+
async fn run_with_levm(
8787
reports: &mut Vec<EFTestReport>,
8888
ef_tests: &[EFTest],
8989
opts: &EFTestRunnerOptions,
@@ -106,7 +106,7 @@ fn run_with_levm(
106106
if !opts.spinner && opts.verbose {
107107
println!("Running test: {:?}", test.name);
108108
}
109-
let ef_test_report = match levm_runner::run_ef_test(test) {
109+
let ef_test_report = match levm_runner::run_ef_test(test).await {
110110
Ok(ef_test_report) => ef_test_report,
111111
Err(EFTestRunnerError::Internal(err)) => return Err(EFTestRunnerError::Internal(err)),
112112
non_internal_errors => {
@@ -147,7 +147,7 @@ fn run_with_levm(
147147
}
148148

149149
/// ### Runs all tests with REVM
150-
fn run_with_revm(
150+
async fn run_with_revm(
151151
reports: &mut Vec<EFTestReport>,
152152
ef_tests: &[EFTest],
153153
opts: &EFTestRunnerOptions,
@@ -176,7 +176,7 @@ fn run_with_revm(
176176
),
177177
opts.spinner,
178178
);
179-
let ef_test_report = match revm_runner::_run_ef_test_revm(test) {
179+
let ef_test_report = match revm_runner::_run_ef_test_revm(test).await {
180180
Ok(ef_test_report) => ef_test_report,
181181
Err(EFTestRunnerError::Internal(err)) => return Err(EFTestRunnerError::Internal(err)),
182182
non_internal_errors => {
@@ -203,7 +203,7 @@ fn run_with_revm(
203203
Ok(())
204204
}
205205

206-
fn re_run_with_revm(
206+
async fn re_run_with_revm(
207207
reports: &mut [EFTestReport],
208208
ef_tests: &[EFTest],
209209
opts: &EFTestRunnerOptions,
@@ -255,7 +255,7 @@ fn re_run_with_revm(
255255
})
256256
.unwrap(),
257257
failed_test_report,
258-
) {
258+
).await {
259259
Ok(re_run_report) => {
260260
failed_test_report.register_re_run_report(re_run_report.clone());
261261
}

‎cmd/ef_tests/state/runner/revm_runner.rs‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ use std::{
3535
sync::Arc,
3636
};
3737

38-
pub fn re_run_failed_ef_test(
38+
pub async fn re_run_failed_ef_test(
3939
test: &EFTest,
4040
failed_test_report: &EFTestReport,
4141
) -> Result<TestReRunReport, EFTestRunnerError> {
@@ -46,7 +46,7 @@ pub fn re_run_failed_ef_test(
4646
match vector_failure {
4747
// We only want to re-run tests that failed in the post-state validation.
4848
EFTestRunnerError::FailedToEnsurePostState(transaction_report, _) => {
49-
match re_run_failed_ef_test_tx(vector, test, transaction_report, &mut re_run_report, fork) {
49+
match re_run_failed_ef_test_tx(vector, test, transaction_report, &mut re_run_report, fork).await {
5050
Ok(_) => continue,
5151
Err(EFTestRunnerError::VMInitializationFailed(reason)) => {
5252
return Err(EFTestRunnerError::Internal(InternalError::ReRunInternal(
@@ -78,14 +78,14 @@ pub fn re_run_failed_ef_test(
7878
Ok(re_run_report)
7979
}
8080

81-
pub fn re_run_failed_ef_test_tx(
81+
pub async fn re_run_failed_ef_test_tx(
8282
vector: &TestVector,
8383
test: &EFTest,
8484
levm_execution_report: &ExecutionReport,
8585
re_run_report: &mut TestReRunReport,
8686
fork: &Fork,
8787
) -> Result<(), EFTestRunnerError> {
88-
let (mut state, _block_hash) = load_initial_state(test);
88+
let (mut state, _block_hash) = load_initial_state(test).await;
8989
let mut revm = prepare_revm_for_tx(&mut state, vector, test, fork)?;
9090
if !test.post.has_vector_for_fork(vector, *fork) {
9191
return Ok(());
@@ -106,7 +106,7 @@ pub fn re_run_failed_ef_test_tx(
106106
test,
107107
re_run_report,
108108
fork,
109-
)?;
109+
).await?;
110110
Ok(())
111111
}
112112

@@ -319,7 +319,7 @@ pub fn compare_levm_revm_execution_results(
319319
Ok(())
320320
}
321321

322-
pub fn ensure_post_state(
322+
pub async fn ensure_post_state(
323323
levm_execution_report: &ExecutionReport,
324324
vector: &TestVector,
325325
revm_state: &mut EvmState,
@@ -331,7 +331,7 @@ pub fn ensure_post_state(
331331
Some(_expected_exception) => {}
332332
// We only want to compare account updates when no exception is expected.
333333
None => {
334-
let store_wrapper = load_initial_state_levm(test);
334+
let store_wrapper = load_initial_state_levm(test).await;
335335
let block_header = store_wrapper
336336
.store
337337
.get_block_header_by_hash(store_wrapper.block_hash)
@@ -359,23 +359,23 @@ pub fn ensure_post_state(
359359
fork,
360360
&levm_account_updates,
361361
&revm_account_updates,
362-
);
362+
).await;
363363
re_run_report.register_account_updates_report(*vector, account_updates_report, *fork);
364364
}
365365
}
366366

367367
Ok(())
368368
}
369369

370-
pub fn compare_levm_revm_account_updates(
370+
pub async fn compare_levm_revm_account_updates(
371371
vector: &TestVector,
372372
test: &EFTest,
373373
fork: &Fork,
374374
levm_account_updates: &[AccountUpdate],
375375
revm_account_updates: &[AccountUpdate],
376376
) -> ComparisonReport {
377-
let levm_post_state_root = post_state_root(levm_account_updates, test);
378-
let revm_post_state_root = post_state_root(revm_account_updates, test);
377+
let levm_post_state_root = post_state_root(levm_account_updates, test).await;
378+
let revm_post_state_root = post_state_root(revm_account_updates, test).await;
379379
let mut initial_accounts: HashMap<Address, Account> = test
380380
.pre
381381
.0
@@ -435,7 +435,7 @@ pub fn compare_levm_revm_account_updates(
435435
}
436436
}
437437

438-
pub fn _run_ef_test_revm(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
438+
pub async fn _run_ef_test_revm(test: &EFTest) -> Result<EFTestReport, EFTestRunnerError> {
439439
let hash = test
440440
._info
441441
.generated_test_hash
@@ -450,7 +450,7 @@ pub fn _run_ef_test_revm(test: &EFTest) -> Result<EFTestReport, EFTestRunnerErro
450450
if !test.post.has_vector_for_fork(vector, *fork) {
451451
continue;
452452
}
453-
match _run_ef_test_tx_revm(vector, test, fork) {
453+
match _run_ef_test_tx_revm(vector, test, fork).await {
454454
Ok(_) => continue,
455455
Err(EFTestRunnerError::VMInitializationFailed(reason)) => {
456456
ef_test_report_fork.register_vm_initialization_failure(reason, *vector);
@@ -490,22 +490,22 @@ pub fn _run_ef_test_revm(test: &EFTest) -> Result<EFTestReport, EFTestRunnerErro
490490
Ok(ef_test_report)
491491
}
492492

493-
pub fn _run_ef_test_tx_revm(
493+
pub async fn _run_ef_test_tx_revm(
494494
vector: &TestVector,
495495
test: &EFTest,
496496
fork: &Fork,
497497
) -> Result<(), EFTestRunnerError> {
498-
let (mut state, _block_hash) = load_initial_state(test);
498+
let (mut state, _block_hash) = load_initial_state(test).await;
499499
let mut revm = prepare_revm_for_tx(&mut state, vector, test, fork)?;
500500
let revm_execution_result = revm.transact_commit();
501501
drop(revm); // Need to drop the state mutable reference.
502502

503-
_ensure_post_state_revm(revm_execution_result, vector, test, &mut state, fork)?;
503+
_ensure_post_state_revm(revm_execution_result, vector, test, &mut state, fork).await?;
504504

505505
Ok(())
506506
}
507507

508-
pub fn _ensure_post_state_revm(
508+
pub async fn _ensure_post_state_revm(
509509
revm_execution_result: Result<RevmExecutionResult, REVMError<StoreError>>,
510510
vector: &TestVector,
511511
test: &EFTest,
@@ -535,7 +535,7 @@ pub fn _ensure_post_state_revm(
535535
None => {
536536
let revm_account_updates =
537537
backends::revm::REVM::get_state_transitions(revm_state);
538-
let pos_state_root = post_state_root(&revm_account_updates, test);
538+
let pos_state_root = post_state_root(&revm_account_updates, test).await;
539539
let expected_post_state_root_hash =
540540
test.post.vector_post_value(vector, *fork).hash;
541541
if expected_post_state_root_hash != pos_state_root {

0 commit comments

Comments
 (0)