Merge pull request #3256 from sky4009/dev

1. unit test code for deferred_pool 2. unit code code for solidity-abi basic

Author: Pana

crates/cfxcore/core/src/transaction_pool/deferred_pool/tests.rs

@@ -1,13 +1,23 @@
 use crate::transaction_pool::TransactionPoolError;
 
 use super::{DeferredPool, InsertResult, TxWithReadyInfo};
-use crate::keylib::{Generator, KeyPair, Random};
-use cfx_types::{Address, AddressSpaceUtil, Space, U256};
+use crate::{
+    keylib::{Generator, KeyPair, Random},
+    verification::PackingCheckResult,
+};
+use cfx_types::{Address, AddressSpaceUtil, AddressWithSpace, Space, U256};
+use cfxkey::Secret;
 use primitives::{
-    transaction::{native_transaction::NativeTransaction, Eip155Transaction},
+    transaction::{
+        native_transaction::NativeTransaction, Eip155Transaction,
+        TypedNativeTransaction,
+    },
     Action, SignedTransaction, Transaction,
 };
-use std::sync::Arc;
+use std::{str::FromStr, sync::Arc};
+
+const PRIVATE_KEY: &str =
+    "74806d258099decd5f5bd500f5b318aaaa0a8a289f8dcb10a9609966d8a0e442";
 
 fn new_test_tx(
     sender: &KeyPair, nonce: usize, gas_price: usize, gas: usize, value: usize,
@@ -267,3 +277,295 @@ fn test_deferred_pool_recalculate_readiness() {
         None
     );
 }
+
+pub fn const_account_with_native_space() -> AddressWithSpace {
+    let secret = Secret::from_str(&PRIVATE_KEY).unwrap();
+    let key_pair = KeyPair::from_secret(secret).unwrap();
+    // return a Native Space address
+    key_pair.address().with_native_space()
+}
+
+pub fn create_signed_transaction(
+    nonce: U256, gas_limit: U256, gas_price: u64, sender: AddressWithSpace,
+    private_key: &str,
+) -> Result<SignedTransaction, Box<dyn std::error::Error>> {
+    let secret = Secret::from_str(&private_key).unwrap();
+
+    let receiver = &sender;
+    // create a tx
+    let typetx = TypedNativeTransaction::Cip155(NativeTransaction {
+        nonce,
+        gas_price: U256::from(gas_price),
+        gas: U256::from(gas_limit),
+        action: Action::Call(receiver.address),
+        value: U256::from(1_000_000u64),
+        storage_limit: 0_u64,
+        epoch_height: 0,
+        chain_id: 1, // Testnet chain ID
+        data: vec![],
+    });
+
+    let transaction = Transaction::Native(typetx);
+    // sign the tx
+    let signed_tx = transaction.sign(&secret);
+
+    Ok(signed_tx)
+}
+
+fn create_tx_with_ready_info(
+    nonce: U256, gas_limit: U256, gas_price: u64, sender: AddressWithSpace,
+    private_key: &str,
+) -> TxWithReadyInfo {
+    // 1.create signed_tx
+    let signed_tx = create_signed_transaction(
+        nonce,
+        gas_limit,
+        gas_price,
+        sender,
+        private_key,
+    )
+    .unwrap();
+
+    // 2. create TxWithReadyInfo
+    let transaction = Arc::new(signed_tx);
+    let packed = false;
+    let sponsored_gas = U256::from(0);
+    let sponsored_storage = 0_u64;
+    let tx_with_ready_info = TxWithReadyInfo::new(
+        transaction,
+        packed,
+        sponsored_gas,
+        sponsored_storage,
+    );
+    tx_with_ready_info
+}
+
+#[test]
+fn test_packing_sampler_valid_transaction() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx1 = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        10000,
+        addr,
+        PRIVATE_KEY,
+    );
+    let tx_clone = tx1.clone();
+    dpool.insert(tx1, false);
+
+    dpool.recalculate_readiness_with_local_info(
+        &addr,
+        U256::from(0),
+        U256::from(1_000_000_000_000_000u64),
+    );
+    assert!(dpool.has_ready_tx(&addr));
+    let validity = |_: &SignedTransaction| PackingCheckResult::Pack;
+    let (txs, gas_used, size_used) = dpool.packing_sampler(
+        Space::Native,
+        U256::from(15000000),
+        40000,
+        10,
+        U256::from(20),
+        validity,
+    );
+
+    assert_eq!(txs.len(), 1);
+    assert_eq!(gas_used, U256::from(21000));
+    assert!(size_used <= 15000000);
+    assert_eq!(txs[0], tx_clone.transaction);
+}
+
+#[test]
+fn test_insert_new_transaction() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+
+    let result = dpool.insert(tx, false);
+    assert!(matches!(result, InsertResult::NewAdded));
+    assert!(dpool.contain_address(&addr));
+    assert!(dpool.check_sender_and_nonce_exists(&addr, &U256::from(0)));
+}
+
+#[test]
+fn test_insert_replace_transaction() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx1 = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+    let tx2 = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        200,
+        addr,
+        PRIVATE_KEY,
+    ); // Higher gas price
+
+    dpool.insert(tx1, false);
+    let result = dpool.insert(tx2, false);
+    assert!(matches!(result, InsertResult::Updated(_)));
+    assert_eq!(dpool.count_less(&addr, &U256::from(1)), 1);
+}
+
+#[test]
+fn test_packing_sampler_empty_limits() {
+    let mut dpool = DeferredPool::new_for_test();
+    let validity = |_: &SignedTransaction| PackingCheckResult::Pack;
+    let (txs, gas_used, size_used) = dpool.packing_sampler(
+        Space::Native,
+        U256::from(0),
+        0,
+        0,
+        U256::from(50),
+        validity,
+    );
+
+    assert!(txs.is_empty());
+    assert_eq!(gas_used, U256::from(0));
+    assert_eq!(size_used, 0);
+}
+
+#[test]
+fn test_estimate_packing_gas_limit() {
+    let dpool = DeferredPool::new_for_test();
+    let (gas_limit, price_limit) = dpool.estimate_packing_gas_limit(
+        Space::Native,
+        U256::from(100_000),
+        U256::from(100),
+        U256::from(50),
+    );
+
+    assert!(gas_limit <= U256::from(200_000)); // gas_target * 2
+    assert!(price_limit >= U256::from(50)); // At least min_base_price
+}
+
+#[test]
+fn test_mark_packed() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+
+    dpool.insert(tx, false);
+    let result = dpool.mark_packed(addr, &U256::from(0), true);
+    assert!(result);
+
+    let result = dpool.check_tx_packed(addr, U256::from(0));
+    assert!(result);
+}
+
+#[test]
+fn test_remove_lowest_nonce() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx1 = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+    let tx2 = create_tx_with_ready_info(
+        U256::from(1),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+
+    dpool.insert(tx1.clone(), false);
+    dpool.insert(tx2, false);
+
+    let removed = dpool.remove_lowest_nonce(&addr).unwrap();
+    assert_eq!(removed.nonce(), &U256::from(0));
+    assert_eq!(dpool.count_less(&addr, &U256::from(2)), 1);
+}
+
+#[test]
+fn test_recalculate_readiness_with_local_info() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx1 = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+    let tx2 = create_tx_with_ready_info(
+        U256::from(1),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+
+    dpool.insert(tx1, false);
+    dpool.insert(tx2, false);
+
+    let result = dpool.recalculate_readiness_with_local_info(
+        &addr,
+        U256::from(0),
+        U256::from(1_000_000_000_000_000u64),
+    );
+    assert!(result.is_some());
+    assert!(dpool.has_ready_tx(&addr));
+}
+
+#[test]
+fn test_get_bucket() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+    dpool.insert(tx, false);
+    let result = dpool.get_bucket(&addr).unwrap();
+    let gas_limit = result.get_lowest_nonce_tx().unwrap().gas_limit();
+    assert_eq!(*gas_limit, U256::from(21000));
+}
+
+#[test]
+fn test_clear_bucket() {
+    let mut dpool = DeferredPool::new_for_test();
+    let addr = const_account_with_native_space();
+    let tx = create_tx_with_ready_info(
+        U256::from(0),
+        U256::from(21000),
+        100,
+        addr,
+        PRIVATE_KEY,
+    );
+    dpool.insert(tx, false);
+    dpool.recalculate_readiness_with_local_info(
+        &addr,
+        U256::from(0),
+        U256::from(1_000_000_000_000_000u64),
+    );
+    assert!(!dpool.buckets.is_empty());
+    assert!(dpool.packing_pool.in_space(Space::Native).len() == 1);
+    dpool.clear();
+    assert!(dpool.buckets.is_empty());
+    assert!(dpool.packing_pool.in_space(Space::Native).len() == 0);
+}