reuse code

adapt change logic

Author: Pana

crates/cfxcore/core/src/transaction_pool/mod.rs

@@ -16,7 +16,9 @@ use crate::{
     block_data_manager::BlockDataManager,
     consensus::BestInformation,
     transaction_pool::{nonce_pool::TxWithReadyInfo, pool_metrics::*},
-    verification::{VerificationConfig, VerifyTxLocalMode, VerifyTxMode},
+    verification::{
+        PackingCheckResult, VerificationConfig, VerifyTxLocalMode, VerifyTxMode,
+    },
 };
 use cfx_executor::{
     machine::Machine, spec::TransitionsEpochHeight, state::State,
@@ -718,6 +720,21 @@ impl TransactionPool {
         }
     }
 
+    fn check_validity(
+        &self, tx: &SignedTransaction, best_epoch_height: u64,
+        best_block_number: u64,
+    ) -> PackingCheckResult {
+        let spec = self.machine.spec(best_block_number, best_epoch_height);
+        let transitions = &self.machine.params().transition_heights;
+
+        self.verification_config.fast_recheck(
+            tx,
+            best_epoch_height,
+            transitions,
+            &spec,
+        )
+    }
+
     pub fn pack_transactions<'a>(
         &self, num_txs: usize, block_gas_limit: U256, evm_gas_limit: U256,
         block_size_limit: usize, mut best_epoch_height: u64,
@@ -727,15 +744,17 @@ impl TransactionPool {
         best_epoch_height += 1;
         // The best block number is not necessary an exact number.
         best_block_number += 1;
+
+        let validity = |tx: &SignedTransaction| {
+            self.check_validity(tx, best_epoch_height, best_block_number)
+        };
+
         inner.pack_transactions(
             num_txs,
             block_gas_limit,
             evm_gas_limit,
             block_size_limit,
-            best_epoch_height,
-            best_block_number,
-            &self.verification_config,
-            &self.machine,
+            validity,
         )
     }
 
@@ -749,16 +768,8 @@ impl TransactionPool {
         // The best block number is not necessary an exact number.
         best_block_number += 1;
 
-        let spec = self.machine.spec(best_block_number, best_epoch_height);
-        let transitions = &self.machine.params().transition_heights;
-
         let validity = |tx: &SignedTransaction| {
-            self.verification_config.fast_recheck(
-                tx,
-                best_epoch_height,
-                transitions,
-                &spec,
-            )
+            self.check_validity(tx, best_epoch_height, best_block_number)
         };
 
         inner.pack_transactions_1559(
@@ -800,7 +811,7 @@ impl TransactionPool {
         for tx in txs {
             gas_used[tx.space()] += *tx.gas_limit();
             min_gas_price[tx.space()] =
-                min_gas_price[tx.space()].min(*tx.gas_limit());
+                min_gas_price[tx.space()].min(*tx.gas_price());
         }
 
         let core_gas_limit =

crates/cfxcore/core/src/transaction_pool/transaction_pool_inner.rs

@@ -7,11 +7,14 @@ use super::{
     TransactionPoolError,
 };
 
-use crate::verification::{PackingCheckResult, VerificationConfig};
+use crate::verification::PackingCheckResult;
 use cfx_executor::machine::Machine;
 use cfx_packing_pool::PackingPoolConfig;
 use cfx_parameters::{
-    block::cspace_block_gas_limit_after_cip1559,
+    block::{
+        cspace_block_gas_limit_after_cip1559,
+        espace_block_gas_limit_of_enabled_block,
+    },
     consensus_internal::ELASTICITY_MULTIPLIER,
     staking::DRIPS_PER_STORAGE_COLLATERAL_UNIT,
 };
@@ -643,35 +646,22 @@ impl TransactionPoolInner {
     /// pack at most num_txs transactions randomly
     pub fn pack_transactions<'a>(
         &mut self, num_txs: usize, block_gas_limit: U256, evm_gas_limit: U256,
-        block_size_limit: usize, best_epoch_height: u64,
-        best_block_number: u64, verification_config: &VerificationConfig,
-        machine: &Machine,
+        block_size_limit: usize,
+        validity: impl Fn(&SignedTransaction) -> PackingCheckResult,
     ) -> Vec<Arc<SignedTransaction>> {
         let mut packed_transactions: Vec<Arc<SignedTransaction>> = Vec::new();
         if num_txs == 0 {
             return packed_transactions;
         }
 
-        let spec = machine.spec(best_block_number, best_epoch_height);
-        let transitions = &machine.params().transition_heights;
-
-        let validity = |tx: &SignedTransaction| {
-            verification_config.fast_recheck(
-                tx,
-                best_epoch_height,
-                transitions,
-                &spec,
-            )
-        };
-
         let (sampled_tx, used_gas, used_size) =
             self.deferred_pool.packing_sampler(
                 Space::Ethereum,
                 std::cmp::min(block_gas_limit, evm_gas_limit),
                 block_size_limit,
                 num_txs,
                 U256::zero(),
-                validity,
+                &validity,
             );
         packed_transactions.extend_from_slice(&sampled_tx);
 
@@ -681,7 +671,7 @@ impl TransactionPoolInner {
             block_size_limit - used_size,
             num_txs - sampled_tx.len(),
             U256::zero(),
-            validity,
+            &validity,
         );
         packed_transactions.extend_from_slice(&sampled_tx);
 
@@ -722,7 +712,9 @@ impl TransactionPoolInner {
             machine.params().can_pack_evm_transaction(best_epoch_height);
 
         let (evm_packed_tx_num, evm_used_size) = if can_pack_evm {
-            let gas_target = block_gas_limit * 5 / 10 / ELASTICITY_MULTIPLIER;
+            let gas_target =
+                espace_block_gas_limit_of_enabled_block(block_gas_limit)
+                    / ELASTICITY_MULTIPLIER;
             let parent_base_price = parent_base_price[Space::Ethereum];
             let min_base_price =
                 machine.params().min_base_price()[Space::Ethereum];

crates/cfxcore/packing-pool/src/packing_batch.rs

@@ -41,7 +41,7 @@ pub enum RemoveError {
 
 #[derive(Debug)]
 pub(crate) struct PackInfo {
-    pub first_gas_price: U256,
+    pub first_priority_gas_price: U256,
     pub total_gas_limit: U256,
 }
 
@@ -65,13 +65,18 @@ impl<TX: PackingPoolTransaction> PackingBatch<TX> {
         self.txs.first().unwrap().max_priority_gas_price()
     }
 
+    #[inline]
+    pub fn first_gas_price(&self) -> U256 {
+        self.txs.first().unwrap().gas_price()
+    }
+
     #[inline]
     pub fn total_gas_limit(&self) -> U256 { self.total_gas_limit }
 
     #[inline]
     pub(crate) fn pack_info(&self) -> PackInfo {
         PackInfo {
-            first_gas_price: self.first_priority_gas_price(),
+            first_priority_gas_price: self.first_priority_gas_price(),
             total_gas_limit: self.total_gas_limit(),
         }
     }
@@ -266,12 +271,13 @@ impl<TX: PackingPoolTransaction> PackingBatch<TX> {
         self, config: &PackingPoolConfig, rng: &mut dyn RngCore,
     ) -> treap_map::Node<PackingPoolMap<TX>> {
         let key = self.txs.first().unwrap().sender();
+        let gas_price = self.first_gas_price();
         let priority_gas_price = self.first_priority_gas_price();
         let sort_key = priority_gas_price;
         let loss_ratio = config.loss_ratio(sort_key);
         let weight = PackingPoolWeight {
             gas_limit: self.total_gas_limit,
-            min_gas_price: priority_gas_price,
+            min_gas_price: gas_price,
             weighted_loss_ratio: loss_ratio * self.total_gas_limit,
             max_loss_ratio: loss_ratio,
         };

crates/cfxcore/packing-pool/src/pool.rs

@@ -254,14 +254,15 @@ fn make_apply_outcome<TX: PackingPoolTransaction, T>(
     old_info: PackInfo, new_info: PackInfo,
     node: &mut Node<PackingPoolMap<TX>>, config: &PackingPoolConfig, out: T,
 ) -> ApplyOpOutcome<T> {
-    let change_gas_price = old_info.first_gas_price != new_info.first_gas_price;
+    let change_gas_price =
+        old_info.first_priority_gas_price != new_info.first_priority_gas_price;
     let change_gas_limit = old_info.total_gas_limit != new_info.total_gas_limit;
 
     let mut update_weight = false;
     let mut update_key = false;
 
     if change_gas_price {
-        let gas_price = new_info.first_gas_price;
+        let gas_price = new_info.first_priority_gas_price;
         node.sort_key = gas_price;
         node.weight.max_loss_ratio = config.loss_ratio(gas_price);
         node.weight.gas_limit = new_info.total_gas_limit;

crates/cfxcore/packing-pool/src/sample.rs

@@ -27,11 +27,11 @@ pub enum SampleTag {
 ///
 /// The iterator operates in three phases:
 /// 1. **Random Sampling Phase**: Based on the random packing algorithm,
-/// addresses are selected from high    to low gas prices of their first
+/// addresses are selected from high to low gas prices of their first
 /// transaction. The probability of inclusion is determined by the algorithm.
-/// Transactions not selected    are placed in a candidate queue.
+/// Transactions not selected are placed in a candidate queue.
 /// 2. **Candidate Queue Phase**: Transactions from the candidate queue are
-/// output in a random order. Transactions    with a higher probability in the
+/// output in a random order. Transactions with a higher probability in the
 /// first phase have a greater chance of appearing earlier in this phase.
 /// 3. **Remaining Transactions Phase**: Remaining addresses are output in
 /// descending order of their first transaction gas prices.

crates/cfxcore/packing-pool/src/transaction.rs

@@ -6,6 +6,7 @@ use primitives::SignedTransaction;
 /// Trait representing a transaction processed by the `PackingPool`.
 pub trait PackingPoolTransaction: Clone {
     type Sender: Default + Ord + Hash + Copy + Debug;
+
     fn sender(&self) -> Self::Sender;
 
     fn nonce(&self) -> U256;