signet-test-utils 0.9.0

Common utilities for testing Signet components
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use alloy::{
    consensus::{
        constants::{ETH_TO_WEI, GWEI_TO_WEI},
        Signed, TxEip1559, TxEnvelope,
    },
    network::TxSigner,
    primitives::{Address, TxKind, U256},
    signers::Signature,
};
use signet_sim::{BlockBuild, SimCache};
use signet_test_utils::{
    evm::TestCfg,
    test_constants::*,
    users::{TEST_SIGNERS, TEST_USERS},
};
use std::sync::Arc;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Layer};
use trevm::{
    revm::{
        database::InMemoryDB,
        inspector::NoOpInspector,
        state::{Account, AccountInfo, EvmState},
        Database, DatabaseCommit,
    },
    NoopBlock,
};

#[tokio::test]
pub async fn test_simulator() {
    let filter = EnvFilter::from_default_env();
    let fmt = tracing_subscriber::fmt::layer().with_filter(filter);
    let registry = tracing_subscriber::registry().with(fmt);
    registry.try_init().unwrap();

    let mut db = InMemoryDB::default();

    // increment the balance for each test signer
    TEST_USERS.iter().copied().for_each(|user| {
        modify_account(&mut db, user, |acct| acct.balance = U256::from(1000 * ETH_TO_WEI)).unwrap();
    });

    let db = Arc::new(db);

    // Set up 10 simple sends with escalating priority fee
    let sim_cache = SimCache::new();
    for (i, sender) in TEST_SIGNERS.iter().enumerate() {
        sim_cache.add_tx(
            signed_simple_send(
                sender,
                TEST_USERS[i],
                U256::from(1000),
                (10 - i) as u128 * GWEI_TO_WEI as u128,
            )
            .await,
            0,
        );
    }

    let time = std::time::Instant::now();

    // Set up the simulator
    let built = BlockBuild::<_, NoOpInspector>::new(
        db,
        TEST_SYS,
        TestCfg,
        NoopBlock,
        std::time::Instant::now() + std::time::Duration::from_millis(200),
        10,
        sim_cache,
        100_000_000,
    )
    .build()
    .await;

    assert!(built.transactions().len() == 10);

    // This asserts that the builder has sorted the transactions by priority
    // fee.
    assert!(built.transactions().windows(2).all(|w| {
        let tx1 = w[0].as_eip1559().unwrap().tx().max_priority_fee_per_gas;
        let tx2 = w[1].as_eip1559().unwrap().tx().max_priority_fee_per_gas;
        tx1 >= tx2
    }));

    dbg!(time.elapsed());
}

/// Modify an account with a closure and commit the modified account.
///
/// This code is reproduced and modified from trevm
fn modify_account<Db, F>(db: &mut Db, addr: Address, f: F) -> Result<AccountInfo, Db::Error>
where
    F: FnOnce(&mut AccountInfo),
    Db: Database + DatabaseCommit,
{
    let mut acct: AccountInfo = db.basic(addr)?.unwrap_or_default();
    let old = acct.clone();
    f(&mut acct);

    let mut acct: Account = acct.into();
    acct.mark_touch();

    let changes: EvmState = [(addr, acct)].into_iter().collect();
    db.commit(changes);
    Ok(old)
}

fn simple_send(to: Address, value: U256, mpfpg: u128) -> TxEip1559 {
    TxEip1559 {
        nonce: 0,
        gas_limit: 21_000,
        to: TxKind::Call(to),
        value,
        chain_id: RU_CHAIN_ID,
        max_fee_per_gas: GWEI_TO_WEI as u128 * 100,
        max_priority_fee_per_gas: mpfpg,
        ..Default::default()
    }
}

async fn signed_simple_send<S: TxSigner<Signature>>(
    from: S,
    to: Address,
    value: U256,
    mpfpg: u128,
) -> TxEnvelope {
    let mut tx = simple_send(to, value, mpfpg);
    let res = from.sign_transaction(&mut tx).await.unwrap();

    Signed::new_unhashed(tx, res).into()
}