reth_transaction_pool/test_utils/
okvalidator.rs

1use std::marker::PhantomData;
2
3use crate::{
4    validate::ValidTransaction, EthPooledTransaction, PoolTransaction, TransactionOrigin,
5    TransactionValidationOutcome, TransactionValidator,
6};
7
8/// A transaction validator that determines all transactions to be valid.
9#[derive(Debug)]
10#[non_exhaustive]
11pub struct OkValidator<T = EthPooledTransaction> {
12    _phantom: PhantomData<T>,
13    /// Whether to mark transactions as propagatable.
14    propagate: bool,
15}
16
17impl<T> OkValidator<T> {
18    /// Determines whether transactions should be allowed to be propagated
19    pub const fn set_propagate_transactions(mut self, propagate: bool) -> Self {
20        self.propagate = propagate;
21        self
22    }
23}
24
25impl<T> Default for OkValidator<T> {
26    fn default() -> Self {
27        Self { _phantom: Default::default(), propagate: false }
28    }
29}
30
31impl<T> TransactionValidator for OkValidator<T>
32where
33    T: PoolTransaction,
34{
35    type Transaction = T;
36
37    async fn validate_transaction(
38        &self,
39        _origin: TransactionOrigin,
40        transaction: Self::Transaction,
41    ) -> TransactionValidationOutcome<Self::Transaction> {
42        // Always return valid
43        let authorities = transaction.authorization_list().map(|auths| {
44            auths.iter().flat_map(|auth| auth.recover_authority()).collect::<Vec<_>>()
45        });
46        TransactionValidationOutcome::Valid {
47            balance: *transaction.cost(),
48            state_nonce: transaction.nonce(),
49            bytecode_hash: None,
50            transaction: ValidTransaction::Valid(transaction),
51            propagate: self.propagate,
52            authorities,
53        }
54    }
55}