openethereum/crates/concensus/miner/src/pool/tests/mod.rs

// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// OpenEthereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

use ethereum_types::U256;
use hash::KECCAK_EMPTY;
use txpool;
use types::transaction::{self, PendingTransaction};

use pool::{verifier, PendingOrdering, PendingSettings, PrioritizationStrategy, TransactionQueue};

pub mod client;
pub mod tx;

use self::{
    client::TestClient,
    tx::{PairExt, Tx, TxExt},
};

// max mem for 3 transaction, this is relative
// to the global use allocator, the value is currently
// set to reflect malloc usage.
// 50 was enough when using jmalloc.
const TEST_QUEUE_MAX_MEM: usize = 100;

fn new_queue() -> TransactionQueue {
    TransactionQueue::new(
        txpool::Options {
            max_count: 3,
            max_per_sender: 3,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    )
}
#[test]
fn should_return_correct_nonces_when_dropped_because_of_limit() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 3,
            max_per_sender: 1,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let (tx1, tx2) = Tx::gas_price(2).signed_pair();
    let sender = tx1.sender();
    let nonce = tx1.tx().nonce;

    // when
    let r1 = txq.import(TestClient::new(), vec![tx1].retracted());
    let r2 = txq.import(TestClient::new(), vec![tx2].retracted());
    assert_eq!(r1, vec![Ok(())]);
    assert_eq!(r2, vec![Err(transaction::Error::LimitReached)]);
    assert_eq!(txq.status().status.transaction_count, 1);

    // then
    assert_eq!(txq.next_nonce(TestClient::new(), &sender), Some(nonce + 1));

    // when
    let tx1 = Tx::gas_price(2).signed();
    let tx2 = Tx::gas_price(2).signed();
    let sender = tx2.sender();
    let tx3 = Tx::gas_price(1).signed();
    let tx4 = Tx::gas_price(3).signed();
    let res = txq.import(TestClient::new(), vec![tx1, tx2].retracted());
    let res2 = txq.import(TestClient::new(), vec![tx3, tx4].retracted());

    // then
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(
        res2,
        vec![
            // The error here indicates reaching the limit
            // and minimal effective gas price taken into account.
            Err(transaction::Error::TooCheapToReplace {
                prev: Some(2.into()),
                new: Some(1.into())
            }),
            Ok(())
        ]
    );
    assert_eq!(txq.status().status.transaction_count, 3);
    // tx2 transaction got dropped because of limit
    // tx1 and tx1' are kept, because they have lower insertion_ids so they are preferred.
    assert_eq!(txq.next_nonce(TestClient::new(), &sender), None);
}

#[test]
fn should_never_drop_local_transactions_from_different_senders() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 3,
            max_per_sender: 1,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let (tx1, tx2) = Tx::gas_price(2).signed_pair();
    let sender = tx1.sender();
    let nonce = tx1.tx().nonce;

    // when
    let r1 = txq.import(TestClient::new(), vec![tx1].local());
    let r2 = txq.import(TestClient::new(), vec![tx2].local());
    assert_eq!(r1, vec![Ok(())]);
    assert_eq!(r2, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);

    // then
    assert_eq!(txq.next_nonce(TestClient::new(), &sender), Some(nonce + 2));

    // when
    let tx1 = Tx::gas_price(2).signed();
    let tx2 = Tx::gas_price(2).signed();
    let tx3 = Tx::gas_price(1).signed();
    let tx4 = Tx::gas_price(3).signed();
    let res = txq.import(TestClient::new(), vec![tx1, tx2].local());
    let res2 = txq.import(TestClient::new(), vec![tx3, tx4].local());

    // then
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(res2, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 6);
    assert_eq!(txq.next_nonce(TestClient::new(), &sender), Some(nonce + 2));
}

#[test]
fn should_handle_same_transaction_imported_twice_with_different_state_nonces() {
    // given
    let txq = new_queue();
    let (tx, tx2) = Tx::default().signed_replacement();
    let hash = tx2.hash();
    let client = TestClient::new().with_nonce(122);

    // First insert one transaction to future
    let res = txq.import(client.clone(), vec![tx].local());
    assert_eq!(res, vec![Ok(())]);
    // next_nonce === None -> transaction is in future
    assert_eq!(txq.next_nonce(client.clone(), &tx2.sender()), None);

    // now import second transaction to current
    let res = txq.import(TestClient::new(), vec![tx2.local()]);

    // and then there should be only one transaction in current (the one with higher gas_price)
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash);
}

#[test]
fn should_move_all_transactions_from_future() {
    // given
    let txq = new_queue();
    let txs = Tx::default().signed_pair();
    let (hash, hash2) = txs.hash();
    let (tx, tx2) = txs;
    let client = TestClient::new().with_nonce(122);

    // First insert one transaction to future
    let res = txq.import(client.clone(), vec![tx.local()]);
    assert_eq!(res, vec![Ok(())]);
    // next_nonce === None -> transaction is in future
    assert_eq!(txq.next_nonce(client.clone(), &tx2.sender()), None);

    // now import second transaction to current
    let res = txq.import(client.clone(), vec![tx2.local()]);

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash);
    assert_eq!(top[1].hash, hash2);
}

#[test]
fn should_drop_transactions_from_senders_without_balance() {
    // given
    let txq = new_queue();
    let tx = Tx::default().signed();
    let client = TestClient::new().with_balance(1);

    // when
    let res = txq.import(client, vec![tx.local()]);

    // then
    assert_eq!(
        res,
        vec![Err(transaction::Error::InsufficientBalance {
            balance: U256::from(1),
            cost: U256::from(21_100),
        })]
    );
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_not_import_transaction_below_min_gas_price_threshold_if_external() {
    // given
    let txq = new_queue();
    let tx = Tx::default();
    txq.set_verifier_options(verifier::Options {
        minimal_gas_price: 3.into(),
        ..Default::default()
    });

    // when
    let res = txq.import(TestClient::new(), vec![tx.signed().unverified()]);

    // then
    assert_eq!(
        res,
        vec![Err(transaction::Error::InsufficientGasPrice {
            minimal: U256::from(3),
            got: U256::from(1),
        })]
    );
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_import_transaction_below_min_gas_price_threshold_if_local() {
    // given
    let txq = new_queue();
    let tx = Tx::default();
    txq.set_verifier_options(verifier::Options {
        minimal_gas_price: 3.into(),
        ..Default::default()
    });

    // when
    let res = txq.import(TestClient::new(), vec![tx.signed().local()]);

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_reject_transaction_from_non_eoa_if_non_eoa_sender_is_not_allowed() {
    // given
    let txq = new_queue();
    let tx = Tx::default();
    let code_hash = [
        0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f,
        0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a,
        0x0f, 0x0e,
    ];

    // when
    let res = txq.import(
        TestClient::new().with_code_hash(code_hash),
        vec![tx.signed().unverified()],
    );

    // then
    assert_eq!(res, vec![Err(transaction::Error::SenderIsNotEOA)]);
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_import_transaction_from_non_eoa_if_non_eoa_sender_is_allowed() {
    // given
    let txq = new_queue();
    let tx = Tx::default();
    let code_hash = [
        0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f,
        0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a, 0x0f, 0x0e, 0x0c, 0x0a,
        0x0f, 0x0e,
    ];
    txq.set_verifier_options(verifier::Options {
        allow_non_eoa_sender: true,
        ..Default::default()
    });

    // when
    let res = txq.import(
        TestClient::new().with_code_hash(code_hash),
        vec![tx.signed().unverified()],
    );

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_import_transaction_if_account_code_hash_is_keccak_empty() {
    // given
    let txq = new_queue();
    let tx = Tx::default();

    // when
    let res = txq.import(
        TestClient::new().with_code_hash(KECCAK_EMPTY),
        vec![tx.signed().unverified()],
    );

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_import_txs_from_same_sender() {
    // given
    let txq = new_queue();

    let txs = Tx::default().signed_pair();
    let (hash, hash2) = txs.hash();

    // when
    txq.import(TestClient::new(), txs.local().into_vec());

    // then
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash);
    assert_eq!(top[1].hash, hash2);
    assert_eq!(top.len(), 2);
}

#[test]
fn should_prioritize_local_transactions_within_same_nonce_height() {
    // given
    let txq = new_queue();
    let tx = Tx::default().signed();
    // the second one has same nonce but higher `gas_price`
    let tx2 = Tx::gas_price(2).signed();
    let (hash, hash2) = (tx.hash(), tx2.hash());
    let client = TestClient::new().with_local(&tx.sender());

    // when
    // first insert the one with higher gas price
    let res = txq.import(client.clone(), vec![tx.local(), tx2.unverified()]);
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // then
    let top = txq.pending(client, PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash); // local should be first
    assert_eq!(top[1].hash, hash2);
    assert_eq!(top.len(), 2);
}

#[test]
fn should_prioritize_reimported_transactions_within_same_nonce_height() {
    // given
    let txq = new_queue();
    let tx = Tx::default().signed();
    // the second one has same nonce but higher `gas_price`
    let tx2 = Tx::gas_price(2).signed();
    let (hash, hash2) = (tx.hash(), tx2.hash());

    // when
    // first insert local one with higher gas price
    // then the one with lower gas price, but from retracted block
    let res = txq.import(TestClient::new(), vec![tx2.unverified(), tx.retracted()]);
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // then
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash); // retracted should be first
    assert_eq!(top[1].hash, hash2);
    assert_eq!(top.len(), 2);
}

#[test]
fn should_not_prioritize_local_transactions_with_different_nonce_height() {
    // given
    let txq = new_queue();
    let txs = Tx::default().signed_pair();
    let (hash, hash2) = txs.hash();
    let (tx, tx2) = txs;

    // when
    let res = txq.import(TestClient::new(), vec![tx.unverified(), tx2.local()]);
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // then
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top[0].hash, hash);
    assert_eq!(top[1].hash, hash2);
    assert_eq!(top.len(), 2);
}

#[test]
fn should_put_transaction_to_futures_if_gap_detected() {
    // given
    let txq = new_queue();
    let (tx, _, tx2) = Tx::default().signed_triple();
    let hash = tx.hash();

    // when
    let res = txq.import(TestClient::new(), vec![tx, tx2].local());

    // then
    assert_eq!(res, vec![Ok(()), Ok(())]);
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top.len(), 1);
    assert_eq!(top[0].hash, hash);
}

#[test]
fn should_handle_min_block() {
    // given
    let txq = new_queue();

    let (tx, tx2) = Tx::default().signed_pair();

    // when
    let res = txq.import(
        TestClient::new(),
        vec![
            verifier::Transaction::Local(PendingTransaction::new(
                tx,
                transaction::Condition::Number(1).into(),
            )),
            tx2.local(),
        ],
    );
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // then
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top.len(), 0);
    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(1, 0));
    assert_eq!(top.len(), 2);
}

#[test]
fn should_correctly_update_futures_when_removing() {
    // given
    let txq = new_queue();
    let txs = Tx::default().signed_pair();

    let res = txq.import(TestClient::new().with_nonce(121), txs.local().into_vec());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);

    // when
    txq.cull(TestClient::new().with_nonce(125));
    // should remove both transactions since they are stalled

    // then
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_move_transactions_if_gap_filled() {
    // given
    let txq = new_queue();
    let (tx, tx1, tx2) = Tx::default().signed_triple();

    let res = txq.import(TestClient::new(), vec![tx, tx2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );

    // when
    let res = txq.import(TestClient::new(), vec![tx1.local()]);
    assert_eq!(res, vec![Ok(())]);

    // then
    assert_eq!(txq.status().status.transaction_count, 3);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        3
    );
}

#[test]
fn should_remove_transaction() {
    // given
    let txq = new_queue();
    let (tx, _, tx2) = Tx::default().signed_triple();

    let res = txq.import(TestClient::default(), vec![tx, tx2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );

    // when
    txq.cull(TestClient::new().with_nonce(124));
    assert_eq!(txq.status().status.transaction_count, 1);
    assert_eq!(
        txq.pending(
            TestClient::new().with_nonce(125),
            PendingSettings::all_prioritized(0, 0)
        )
        .len(),
        1
    );
    txq.cull(TestClient::new().with_nonce(126));

    // then
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_move_transactions_to_future_if_gap_introduced() {
    // given
    let txq = new_queue();
    let (tx, tx2) = Tx::default().signed_pair();
    let hash = tx.hash();
    let tx3 = Tx::default().signed();

    let res = txq.import(TestClient::new(), vec![tx3, tx2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );

    let res = txq.import(TestClient::new(), vec![tx].local());
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 3);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        3
    );

    // when
    txq.remove(vec![&hash], true);

    // then
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );
}

#[test]
fn should_clear_queue() {
    // given
    let txq = new_queue();
    let txs = Tx::default().signed_pair();

    // add
    txq.import(TestClient::new(), txs.local().into_vec());
    assert_eq!(txq.status().status.transaction_count, 2);

    // when
    txq.clear();

    // then
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_prefer_current_transactions_when_hitting_the_limit() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let (tx, tx2) = Tx::default().signed_pair();
    let hash = tx.hash();
    let sender = tx.sender();

    let res = txq.import(TestClient::new(), vec![tx2.unverified()]);
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);

    // when
    let res = txq.import(TestClient::new(), vec![tx.unverified()]);

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);

    let top = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(top.len(), 1);
    assert_eq!(top[0].hash, hash);
    assert_eq!(txq.next_nonce(TestClient::new(), &sender), Some(124.into()));
}

#[test]
fn should_drop_transactions_with_old_nonces() {
    let txq = new_queue();
    let tx = Tx::default().signed();

    // when
    let res = txq.import(TestClient::new().with_nonce(125), vec![tx.unverified()]);

    // then
    assert_eq!(res, vec![Err(transaction::Error::Old)]);
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_not_insert_same_transaction_twice() {
    // given
    let txq = new_queue();
    let (_tx1, tx2) = Tx::default().signed_pair();
    let res = txq.import(TestClient::new(), vec![tx2.clone().local()]);
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);

    // when
    let res = txq.import(TestClient::new(), vec![tx2.local()]);

    // then
    assert_eq!(res, vec![Err(transaction::Error::AlreadyImported)]);
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_accept_same_transaction_twice_if_removed() {
    // given
    let txq = new_queue();
    let txs = Tx::default().signed_pair();
    let (tx1, _) = txs.clone();
    let (hash, _) = txs.hash();

    let res = txq.import(TestClient::new(), txs.local().into_vec());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        2
    );

    // when
    txq.remove(vec![&hash], true);
    assert_eq!(txq.status().status.transaction_count, 1);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        0
    );

    let res = txq.import(TestClient::new(), vec![tx1].local());
    assert_eq!(res, vec![Ok(())]);

    // then
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        2
    );
}

#[test]
fn should_not_replace_same_transaction_if_the_fee_is_less_than_minimal_bump() {
    // given
    let txq = new_queue();
    let (tx, tx2) = Tx::gas_price(20).signed_replacement();
    let (tx3, tx4) = Tx::gas_price(1).signed_replacement();
    let client = TestClient::new().with_balance(1_000_000);

    // when
    let res = txq.import(client.clone(), vec![tx, tx3].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);

    let res = txq.import(client.clone(), vec![tx2, tx4].local());

    // then
    assert_eq!(
        res,
        vec![
            Err(transaction::Error::TooCheapToReplace {
                prev: None,
                new: None
            }),
            Ok(())
        ]
    );
    assert_eq!(txq.status().status.transaction_count, 2);
    assert_eq!(
        txq.pending(client.clone(), PendingSettings::all_prioritized(0, 0))[0]
            .signed()
            .tx()
            .gas_price,
        U256::from(20)
    );
    assert_eq!(
        txq.pending(client.clone(), PendingSettings::all_prioritized(0, 0))[1]
            .signed()
            .tx()
            .gas_price,
        U256::from(2)
    );
}

#[test]
fn should_return_none_when_transaction_from_given_address_does_not_exist() {
    // given
    let txq = new_queue();

    // then
    assert_eq!(txq.next_nonce(TestClient::new(), &Default::default()), None);
}

#[test]
fn should_return_correct_nonce_when_transactions_from_given_address_exist() {
    // given
    let txq = new_queue();
    let tx = Tx::default().signed();
    let from = tx.sender();
    let nonce = tx.tx().nonce;

    // when
    txq.import(TestClient::new(), vec![tx.local()]);

    // then
    assert_eq!(txq.next_nonce(TestClient::new(), &from), Some(nonce + 1));
}

#[test]
fn should_return_valid_last_nonce_after_cull() {
    // given
    let txq = new_queue();
    let (tx1, _, tx2) = Tx::default().signed_triple();
    let sender = tx1.sender();

    // when
    // Second should go to future
    let res = txq.import(TestClient::new(), vec![tx1, tx2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);
    // Now block is imported
    let client = TestClient::new().with_nonce(124);
    txq.cull(client.clone());
    // tx2 should be not be promoted to current
    assert_eq!(
        txq.pending(client.clone(), PendingSettings::all_prioritized(0, 0))
            .len(),
        0
    );

    // then
    assert_eq!(txq.next_nonce(client.clone(), &sender), None);
    assert_eq!(
        txq.next_nonce(client.with_nonce(125), &sender),
        Some(126.into())
    );
}

#[test]
fn should_return_true_if_there_is_local_transaction_pending() {
    // given
    let txq = new_queue();
    let (tx1, tx2) = Tx::default().signed_pair();
    assert_eq!(txq.has_local_pending_transactions(), false);
    let client = TestClient::new().with_local(&tx1.sender());

    // when
    let res = txq.import(client.clone(), vec![tx1.unverified(), tx2.local()]);
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // then
    assert_eq!(txq.has_local_pending_transactions(), true);
}

#[test]
fn should_reject_transactions_below_base_gas() {
    // given
    let txq = new_queue();
    let tx = Tx::default().signed();

    // when
    let res = txq.import(
        TestClient::new().with_gas_required(100_001),
        vec![tx].local(),
    );

    // then
    assert_eq!(
        res,
        vec![Err(transaction::Error::InsufficientGas {
            minimal: 100_001.into(),
            got: 21_000.into(),
        })]
    );
}

#[test]
fn should_remove_out_of_date_transactions_occupying_queue() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 105,
            max_per_sender: 3,
            max_mem_usage: 5_000_000,
        },
        verifier::Options {
            minimal_gas_price: 10.into(),
            ..Default::default()
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    // that transaction will be occupying the queue
    let (_, tx) = Tx::default().signed_pair();
    let res = txq.import(TestClient::new(), vec![tx.local()]);
    assert_eq!(res, vec![Ok(())]);
    // This should not clear the transaction (yet)
    txq.cull(TestClient::new());
    assert_eq!(txq.status().status.transaction_count, 1);

    // Now insert at least 100 transactions to have the other one marked as future.
    for _ in 0..34 {
        let (tx1, tx2, tx3) = Tx::default().signed_triple();
        txq.import(TestClient::new(), vec![tx1, tx2, tx3].local());
    }
    assert_eq!(txq.status().status.transaction_count, 103);

    // when
    txq.cull(TestClient::new());

    // then
    assert_eq!(txq.status().status.transaction_count, 102);
}

#[test]
fn should_accept_local_transactions_below_min_gas_price() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 3,
            max_per_sender: 3,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 10.into(),
            ..Default::default()
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let tx = Tx::gas_price(1).signed();

    // when
    let res = txq.import(TestClient::new(), vec![tx.local()]);
    assert_eq!(res, vec![Ok(())]);

    // then
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );
}

#[test]
fn should_accept_local_service_transaction() {
    // given
    let txq = new_queue();
    let tx = Tx::gas_price(0).signed();

    // when
    let res = txq.import(TestClient::new().with_local(&tx.sender()), vec![tx.local()]);
    assert_eq!(res, vec![Ok(())]);

    // then
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0))
            .len(),
        1
    );
}

#[test]
fn should_not_accept_external_service_transaction_if_sender_not_certified() {
    // given
    let txq = new_queue();
    let tx1 = Tx::gas_price(0).signed().unverified();
    let tx2 = Tx::gas_price(0).signed().retracted();
    let tx3 = Tx::gas_price(0).signed().unverified();

    // when
    let res = txq.import(TestClient::new(), vec![tx1, tx2]);
    assert_eq!(
        res,
        vec![
            Err(transaction::Error::InsufficientGasPrice {
                minimal: 1.into(),
                got: 0.into(),
            }),
            Err(transaction::Error::InsufficientGasPrice {
                minimal: 1.into(),
                got: 0.into(),
            }),
        ]
    );

    // then
    let res = txq.import(TestClient::new().with_service_transaction(), vec![tx3]);
    assert_eq!(res, vec![Ok(())]);
}

#[test]
fn should_not_return_transactions_over_nonce_cap() {
    // given
    let txq = new_queue();
    let (tx1, tx2, tx3) = Tx::default().signed_triple();
    let res = txq.import(TestClient::new(), vec![tx1, tx2, tx3].local());
    assert_eq!(res, vec![Ok(()), Ok(()), Ok(())]);

    // when
    let all = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    // This should invalidate the cache!
    let limited = txq.pending(
        TestClient::new(),
        PendingSettings {
            block_number: 0,
            current_timestamp: 0,
            nonce_cap: Some(123.into()),
            max_len: usize::max_value(),
            ordering: PendingOrdering::Priority,
            includable_boundary: Default::default(),
        },
    );

    // then
    assert_eq!(all.len(), 3);
    assert_eq!(limited.len(), 1);
}

#[test]
fn should_return_cached_pending_even_if_unordered_is_requested() {
    // given
    let txq = new_queue();
    let tx1 = Tx::default().signed();
    let (tx2_1, tx2_2) = Tx::default().signed_pair();
    let tx2_1_hash = tx2_1.hash();
    let res = txq.import(TestClient::new(), vec![tx1].unverified());
    assert_eq!(res, vec![Ok(())]);
    let res = txq.import(TestClient::new(), vec![tx2_1, tx2_2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // when
    let all = txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 0));
    assert_eq!(all[0].hash, tx2_1_hash);
    assert_eq!(all.len(), 3);

    // This should not invalidate the cache!
    let limited = txq.pending(
        TestClient::new(),
        PendingSettings {
            block_number: 0,
            current_timestamp: 0,
            nonce_cap: None,
            max_len: 3,
            ordering: PendingOrdering::Unordered,
            includable_boundary: Default::default(),
        },
    );

    // then
    assert_eq!(all, limited);
}

#[test]
fn should_return_unordered_and_not_populate_the_cache() {
    // given
    let txq = new_queue();
    let tx1 = Tx::default().signed();
    let (tx2_1, tx2_2) = Tx::default().signed_pair();
    let res = txq.import(TestClient::new(), vec![tx1].unverified());
    assert_eq!(res, vec![Ok(())]);
    let res = txq.import(TestClient::new(), vec![tx2_1, tx2_2].local());
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // when
    // This should not invalidate the cache!
    let limited = txq.pending(
        TestClient::new(),
        PendingSettings {
            block_number: 0,
            current_timestamp: 0,
            nonce_cap: None,
            max_len: usize::max_value(),
            ordering: PendingOrdering::Unordered,
            includable_boundary: Default::default(),
        },
    );

    // then
    assert_eq!(limited.len(), 3);
    assert!(!txq.is_pending_cached());
}

#[test]
fn should_clear_cache_after_timeout_for_local() {
    // given
    let txq = new_queue();
    let (tx, tx2) = Tx::default().signed_pair();
    let res = txq.import(
        TestClient::new(),
        vec![
            verifier::Transaction::Local(PendingTransaction::new(
                tx,
                transaction::Condition::Timestamp(1000).into(),
            )),
            tx2.local(),
        ],
    );
    assert_eq!(res, vec![Ok(()), Ok(())]);

    // This should populate cache and set timestamp to 1
    // when
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 1))
            .len(),
        0
    );
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 1000))
            .len(),
        0
    );

    // This should invalidate the cache and trigger transaction ready.
    // then
    assert_eq!(
        txq.pending(TestClient::new(), PendingSettings::all_prioritized(0, 1002))
            .len(),
        2
    );
}

#[test]
fn should_reject_big_transaction() {
    let txq = new_queue();
    let big_tx = Tx::default().big_one();
    let res = txq.import(
        TestClient::new(),
        vec![verifier::Transaction::Local(PendingTransaction::new(
            big_tx,
            transaction::Condition::Timestamp(1000).into(),
        ))],
    );
    assert_eq!(res, vec![Err(transaction::Error::TooBig)]);
}

#[test]
fn should_include_local_transaction_to_a_full_pool() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let tx1 = Tx::gas_price(10_000).signed().unverified();
    let tx2 = Tx::gas_price(1).signed().local();

    let res = txq.import(TestClient::new().with_balance(1_000_000_000), vec![tx1]);
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);

    // when
    let res = txq.import(TestClient::new(), vec![tx2]);
    assert_eq!(res, vec![Ok(())]);

    // then
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_avoid_verifying_transaction_already_in_pool() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let client = TestClient::new().with_balance(1_000_000_000);
    let tx1 = Tx::gas_price(2).signed().unverified();

    let res = txq.import(client.clone(), vec![tx1.clone()]);
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
    assert!(client.was_verification_triggered());

    // when
    let client = TestClient::new();
    let res = txq.import(client.clone(), vec![tx1]);
    assert_eq!(res, vec![Err(transaction::Error::AlreadyImported)]);
    assert!(!client.was_verification_triggered());

    // then
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_avoid_reverifying_recently_rejected_transactions() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );

    let client = TestClient::new();
    let tx1 = Tx::gas_price(10_000).signed().unverified();

    let res = txq.import(client.clone(), vec![tx1.clone()]);
    assert_eq!(
        res,
        vec![Err(transaction::Error::InsufficientBalance {
            balance: 0xf67c.into(),
            cost: 0xc8458e4.into(),
        })]
    );
    assert_eq!(txq.status().status.transaction_count, 0);
    assert!(client.was_verification_triggered());

    // when
    let client = TestClient::new();
    let res = txq.import(client.clone(), vec![tx1]);
    assert_eq!(
        res,
        vec![Err(transaction::Error::InsufficientBalance {
            balance: 0xf67c.into(),
            cost: 0xc8458e4.into(),
        })]
    );
    assert!(!client.was_verification_triggered());

    // then
    assert_eq!(txq.status().status.transaction_count, 0);
}

#[test]
fn should_reject_early_in_case_gas_price_is_less_than_min_effective() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: false,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    let client = TestClient::new().with_balance(1_000_000_000);
    let tx1 = Tx::gas_price(2).signed().unverified();

    let res = txq.import(client.clone(), vec![tx1]);
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
    assert!(client.was_verification_triggered());

    // when
    let client = TestClient::new();
    let tx1 = Tx::default().signed().unverified();
    let res = txq.import(client.clone(), vec![tx1]);
    assert_eq!(
        res,
        vec![Err(transaction::Error::TooCheapToReplace {
            prev: Some(2.into()),
            new: Some(1.into()),
        })]
    );
    assert!(!client.was_verification_triggered());

    // then
    assert_eq!(txq.status().status.transaction_count, 1);
}

#[test]
fn should_not_reject_early_in_case_gas_price_is_less_than_min_effective() {
    // given
    let txq = TransactionQueue::new(
        txpool::Options {
            max_count: 1,
            max_per_sender: 2,
            max_mem_usage: TEST_QUEUE_MAX_MEM,
        },
        verifier::Options {
            minimal_gas_price: 1.into(),
            block_gas_limit: 1_000_000.into(),
            tx_gas_limit: 1_000_000.into(),
            no_early_reject: true,
            block_base_fee: None,
            allow_non_eoa_sender: false,
        },
        PrioritizationStrategy::GasPriceOnly,
    );
    // when
    let tx1 = Tx::gas_price(2).signed();
    let client = TestClient::new().with_local(&tx1.sender());
    let res = txq.import(client.clone(), vec![tx1.unverified()]);

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 1);
    assert!(client.was_verification_triggered());

    // when
    let tx1 = Tx::gas_price(1).signed();
    let client = TestClient::new().with_local(&tx1.sender());
    let res = txq.import(client.clone(), vec![tx1.unverified()]);

    // then
    assert_eq!(res, vec![Ok(())]);
    assert_eq!(txq.status().status.transaction_count, 2);
    assert!(client.was_verification_triggered());
}