Merge branch 'master' into feat/removeLegacyERpc

Author: Pana

Cargo.lock

@@ -40,6 +40,7 @@ parity-version = { workspace = true }
 tokio = { workspace = true, features = ["rt"] }
 bls-signatures = { workspace = true }
 cfx-executor = { workspace = true }
+cfx-execute-helper = { workspace = true }
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies.jemallocator]
 version = "0.3.2"
@@ -54,7 +55,7 @@ u64-mpt-db-key = ["client/u64_mpt_db_key"]
 # it will be enabled across all paths depending on that package. 
 # (https://doc.rust-lang.org/cargo/reference/features.html#feature-unification)
 blst-portable = ["bls-signatures/blst-portable"]
-align_evm = ["cfx-executor/align_evm"]
+align_evm = ["cfx-executor/align_evm", "cfx-execute-helper/align_evm"]
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }

bins/conflux/Cargo.toml

@@ -48,7 +48,7 @@ impl FromStr for Space {
         match s {
             "native" => Ok(Space::Native),
             "evm" => Ok(Space::Ethereum),
-            _ => Err("Invalid space str".to_owned()),
+            _ => Err(format!("Unrecognized space: {}", s)),
         }
     }
 }

crates/cfx_types/src/space.rs

@@ -505,7 +505,13 @@ impl ConsensusExecutor {
         // the lock, there might be a checkpoint coming in to break
         // index
         for state_block_hash in waiting_blocks {
-            self.wait_for_result(state_block_hash)?;
+            let commitment = self.wait_for_result(state_block_hash)?;
+            self.handler.data_man.insert_epoch_execution_commitment(
+                state_block_hash,
+                commitment.state_root_with_aux_info,
+                commitment.receipts_root,
+                commitment.logs_bloom_hash,
+            );
         }
         // Now we need to wait for the execution information of all missing
         // blocks to come back

crates/cfxcore/core/src/consensus/consensus_inner/consensus_executor/mod.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);
+}

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

@@ -21,3 +21,6 @@ typemap = { workspace = true }
 alloy-rpc-types-trace = { workspace = true }
 geth-tracer = { workspace = true }
 cfx-parity-trace-types = { workspace = true }
+
+[features]
+align_evm = ["cfx-vm-types/align_evm", "cfx-executor/align_evm"]

crates/execution/execute-helper/Cargo.toml

@@ -133,6 +133,7 @@ impl<'a> EstimationContext<'a> {
     pub fn transact_virtual(
         &mut self, mut tx: SignedTransaction, request: EstimateRequest,
     ) -> DbResult<(ExecutionOutcome, EstimateExt)> {
+        #[cfg(not(feature = "align_evm"))]
         if let Some(outcome) = self.check_cip130(&tx, &request) {
             return Ok(outcome);
         }
@@ -400,7 +401,11 @@ impl<'a> EstimationContext<'a> {
 }
 
 fn estimated_gas_limit(executed: &Executed, tx: &SignedTransaction) -> U256 {
+    #[cfg(not(feature = "align_evm"))]
     let cip130_min_gas_limit = U256::from(tx.data().len() * 100);
+    #[cfg(feature = "align_evm")]
+    let cip130_min_gas_limit = U256::zero();
+
     let eip7623_gas_limit = 21000
         + tx.data()
             .iter()