Replace by fee on mempool

consensus/core/src/api/args.rs

@@ -0,0 +1,47 @@
+use std::collections::HashMap;
+
+use crate::tx::TransactionId;
+
+/// A struct provided to consensus for transaction validation processing calls
+#[derive(Clone, Debug, Default)]
+pub struct TransactionValidationArgs {
+    /// Optional fee/mass threshold above which a bound transaction in not rejected
+    pub fee_per_mass_threshold: Option<f64>,
+}
+
+impl TransactionValidationArgs {
+    pub fn new(fee_per_mass_threshold: Option<f64>) -> Self {
+        Self { fee_per_mass_threshold }
+    }
+}
+
+/// A struct provided to consensus for transactions validation processing calls
+pub struct TransactionBatchValidationArgs {
+    tx_args: HashMap<TransactionId, TransactionValidationArgs>,
+}
+
+impl TransactionBatchValidationArgs {
+    const DEFAULT_ARGS: TransactionValidationArgs = TransactionValidationArgs { fee_per_mass_threshold: None };
+
+    pub fn new() -> Self {
+        Self { tx_args: HashMap::new() }
+    }
+
+    /// Set some fee/mass threshold for transaction `transaction_id`.
+    pub fn set_fee_per_mass_threshold(&mut self, transaction_id: TransactionId, threshold: f64) {
+        self.tx_args
+            .entry(transaction_id)
+            .and_modify(|x| x.fee_per_mass_threshold = Some(threshold))
+            .or_insert(TransactionValidationArgs::new(Some(threshold)));
+    }
+
+    pub fn get(&self, transaction_id: &TransactionId) -> &TransactionValidationArgs {
+        self.tx_args.get(transaction_id).unwrap_or(&Self::DEFAULT_ARGS)
+    }
+}
+
+impl Default for TransactionBatchValidationArgs {
+    fn default() -> Self {
+        Self::new()
+    }
+}

consensus/core/src/api/mod.rs

@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use crate::{
     acceptance_data::AcceptanceData,
+    api::args::{TransactionBatchValidationArgs, TransactionValidationArgs},
     block::{Block, BlockTemplate, TemplateBuildMode, TemplateTransactionSelector, VirtualStateApproxId},
     blockstatus::BlockStatus,
     coinbase::MinerData,
@@ -25,6 +26,7 @@ use kaspa_hashes::Hash;
 
 pub use self::stats::{BlockCount, ConsensusStats};
 
+pub mod args;
 pub mod counters;
 pub mod stats;
 
@@ -62,14 +64,18 @@ pub trait ConsensusApi: Send + Sync {
     }
 
     /// Populates the mempool transaction with maximally found UTXO entry data and proceeds to full transaction
-    /// validation if all are found. If validation is successful, also [`transaction.calculated_fee`] is expected to be populated.
-    fn validate_mempool_transaction(&self, transaction: &mut MutableTransaction) -> TxResult<()> {
+    /// validation if all are found. If validation is successful, also `transaction.calculated_fee` is expected to be populated.
+    fn validate_mempool_transaction(&self, transaction: &mut MutableTransaction, args: &TransactionValidationArgs) -> TxResult<()> {
         unimplemented!()
     }
 
     /// Populates the mempool transactions with maximally found UTXO entry data and proceeds to full transactions
-    /// validation if all are found. If validation is successful, also [`transaction.calculated_fee`] is expected to be populated.
-    fn validate_mempool_transactions_in_parallel(&self, transactions: &mut [MutableTransaction]) -> Vec<TxResult<()>> {
+    /// validation if all are found. If validation is successful, also `transaction.calculated_fee` is expected to be populated.
+    fn validate_mempool_transactions_in_parallel(
+        &self,
+        transactions: &mut [MutableTransaction],
+        args: &TransactionBatchValidationArgs,
+    ) -> Vec<TxResult<()>> {
         unimplemented!()
     }
 

consensus/core/src/errors/tx.rs

@@ -88,6 +88,9 @@ pub enum TxRuleError {
 
     #[error("calculated contextual mass (including storage mass) {0} is not equal to the committed mass field {1}")]
     WrongMass(u64, u64),
+
+    #[error("fee per compute mass ratio is not greater than the threshold")]
+    FeePerMassTooLow,
 }
 
 pub type TxResult<T> = std::result::Result<T, TxRuleError>;

consensus/core/src/tx.rs

@@ -406,6 +406,13 @@ impl<T: AsRef<Transaction>> MutableTransaction<T> {
             *entry = None;
         }
     }
+
+    pub fn calculated_fee_per_compute_mass(&self) -> Option<f64> {
+        match (self.calculated_fee, self.calculated_compute_mass) {
+            (Some(fee), Some(compute_mass)) => Some(fee as f64 / compute_mass as f64),
+            _ => None,
+        }
+    }
 }
 
 impl<T: AsRef<Transaction>> AsRef<Transaction> for MutableTransaction<T> {

consensus/src/consensus/mod.rs

@@ -40,7 +40,11 @@ use crate::{
 };
 use kaspa_consensus_core::{
     acceptance_data::AcceptanceData,
-    api::{stats::BlockCount, BlockValidationFutures, ConsensusApi, ConsensusStats},
+    api::{
+        args::{TransactionBatchValidationArgs, TransactionValidationArgs},
+        stats::BlockCount,
+        BlockValidationFutures, ConsensusApi, ConsensusStats,
+    },
     block::{Block, BlockTemplate, TemplateBuildMode, TemplateTransactionSelector, VirtualStateApproxId},
     blockhash::BlockHashExtensions,
     blockstatus::BlockStatus,
@@ -49,9 +53,10 @@ use kaspa_consensus_core::{
     errors::{
         coinbase::CoinbaseResult,
         consensus::{ConsensusError, ConsensusResult},
+        difficulty::DifficultyError,
+        pruning::PruningImportError,
         tx::TxResult,
     },
-    errors::{difficulty::DifficultyError, pruning::PruningImportError},
     header::Header,
     muhash::MuHashExtensions,
     network::NetworkType,
@@ -418,13 +423,17 @@ impl ConsensusApi for Consensus {
         BlockValidationFutures { block_task: Box::pin(block_task), virtual_state_task: Box::pin(virtual_state_task) }
     }
 
-    fn validate_mempool_transaction(&self, transaction: &mut MutableTransaction) -> TxResult<()> {
-        self.virtual_processor.validate_mempool_transaction(transaction)?;
+    fn validate_mempool_transaction(&self, transaction: &mut MutableTransaction, args: &TransactionValidationArgs) -> TxResult<()> {
+        self.virtual_processor.validate_mempool_transaction(transaction, args)?;
         Ok(())
     }
 
-    fn validate_mempool_transactions_in_parallel(&self, transactions: &mut [MutableTransaction]) -> Vec<TxResult<()>> {
-        self.virtual_processor.validate_mempool_transactions_in_parallel(transactions)
+    fn validate_mempool_transactions_in_parallel(
+        &self,
+        transactions: &mut [MutableTransaction],
+        args: &TransactionBatchValidationArgs,
+    ) -> Vec<TxResult<()>> {
+        self.virtual_processor.validate_mempool_transactions_in_parallel(transactions, args)
     }
 
     fn populate_mempool_transaction(&self, transaction: &mut MutableTransaction) -> TxResult<()> {

consensus/src/pipeline/virtual_processor/processor.rs

@@ -48,6 +48,7 @@ use crate::{
 };
 use kaspa_consensus_core::{
     acceptance_data::AcceptanceData,
+    api::args::{TransactionBatchValidationArgs, TransactionValidationArgs},
     block::{BlockTemplate, MutableBlock, TemplateBuildMode, TemplateTransactionSelector},
     blockstatus::BlockStatus::{StatusDisqualifiedFromChain, StatusUTXOValid},
     coinbase::MinerData,
@@ -757,23 +758,28 @@ impl VirtualStateProcessor {
         virtual_utxo_view: &impl UtxoView,
         virtual_daa_score: u64,
         virtual_past_median_time: u64,
+        args: &TransactionValidationArgs,
     ) -> TxResult<()> {
         self.transaction_validator.validate_tx_in_isolation(&mutable_tx.tx)?;
         self.transaction_validator.utxo_free_tx_validation(&mutable_tx.tx, virtual_daa_score, virtual_past_median_time)?;
-        self.validate_mempool_transaction_in_utxo_context(mutable_tx, virtual_utxo_view, virtual_daa_score)?;
+        self.validate_mempool_transaction_in_utxo_context(mutable_tx, virtual_utxo_view, virtual_daa_score, args)?;
         Ok(())
     }
 
-    pub fn validate_mempool_transaction(&self, mutable_tx: &mut MutableTransaction) -> TxResult<()> {
+    pub fn validate_mempool_transaction(&self, mutable_tx: &mut MutableTransaction, args: &TransactionValidationArgs) -> TxResult<()> {
         let virtual_read = self.virtual_stores.read();
         let virtual_state = virtual_read.state.get().unwrap();
         let virtual_utxo_view = &virtual_read.utxo_set;
         let virtual_daa_score = virtual_state.daa_score;
         let virtual_past_median_time = virtual_state.past_median_time;
-        self.validate_mempool_transaction_impl(mutable_tx, virtual_utxo_view, virtual_daa_score, virtual_past_median_time)
+        self.validate_mempool_transaction_impl(mutable_tx, virtual_utxo_view, virtual_daa_score, virtual_past_median_time, args)
     }
 
-    pub fn validate_mempool_transactions_in_parallel(&self, mutable_txs: &mut [MutableTransaction]) -> Vec<TxResult<()>> {
+    pub fn validate_mempool_transactions_in_parallel(
+        &self,
+        mutable_txs: &mut [MutableTransaction],
+        args: &TransactionBatchValidationArgs,
+    ) -> Vec<TxResult<()>> {
         let virtual_read = self.virtual_stores.read();
         let virtual_state = virtual_read.state.get().unwrap();
         let virtual_utxo_view = &virtual_read.utxo_set;
@@ -784,7 +790,13 @@ impl VirtualStateProcessor {
             mutable_txs
                 .par_iter_mut()
                 .map(|mtx| {
-                    self.validate_mempool_transaction_impl(mtx, &virtual_utxo_view, virtual_daa_score, virtual_past_median_time)
+                    self.validate_mempool_transaction_impl(
+                        mtx,
+                        &virtual_utxo_view,
+                        virtual_daa_score,
+                        virtual_past_median_time,
+                        args.get(&mtx.id()),
+                    )
                 })
                 .collect::<Vec<TxResult<()>>>()
         })

consensus/src/pipeline/virtual_processor/utxo_validation.rs

@@ -15,6 +15,7 @@ use crate::{
 };
 use kaspa_consensus_core::{
     acceptance_data::{AcceptedTxEntry, MergesetBlockAcceptanceData},
+    api::args::TransactionValidationArgs,
     coinbase::*,
     hashing,
     header::Header,
@@ -248,7 +249,8 @@ impl VirtualStateProcessor {
             }
         }
         let populated_tx = PopulatedTransaction::new(transaction, entries);
-        let res = self.transaction_validator.validate_populated_transaction_and_get_fee(&populated_tx, pov_daa_score, flags);
+        let res =
+            self.transaction_validator.validate_populated_transaction_and_get_fee(&populated_tx, pov_daa_score, flags, None, None);
         match res {
             Ok(calculated_fee) => Ok(ValidatedTransaction::new(populated_tx, calculated_fee)),
             Err(tx_rule_error) => {
@@ -290,6 +292,7 @@ impl VirtualStateProcessor {
         mutable_tx: &mut MutableTransaction,
         utxo_view: &impl UtxoView,
         pov_daa_score: u64,
+        args: &TransactionValidationArgs,
     ) -> TxResult<()> {
         self.populate_mempool_transaction_in_utxo_context(mutable_tx, utxo_view)?;
 
@@ -312,6 +315,8 @@ impl VirtualStateProcessor {
             &mutable_tx.as_verifiable(),
             pov_daa_score,
             TxValidationFlags::SkipMassCheck, // we can skip the mass check since we just set it
+            mutable_tx.calculated_compute_mass,
+            args.fee_per_mass_threshold,
         )?;
         mutable_tx.calculated_fee = Some(calculated_fee);
         Ok(())

consensus/src/processes/transaction_validator/transaction_validator_populated.rs

@@ -27,10 +27,13 @@ impl TransactionValidator {
         tx: &impl VerifiableTransaction,
         pov_daa_score: u64,
         flags: TxValidationFlags,
+        compute_mass: Option<u64>,
+        fee_per_mass_threshold: Option<f64>,
     ) -> TxResult<u64> {
         self.check_transaction_coinbase_maturity(tx, pov_daa_score)?;
         let total_in = self.check_transaction_input_amounts(tx)?;
         let total_out = Self::check_transaction_output_values(tx, total_in)?;
+        let fee = total_in - total_out;
         if flags != TxValidationFlags::SkipMassCheck && pov_daa_score > self.storage_mass_activation_daa_score {
             // Storage mass hardfork was activated
             self.check_mass_commitment(tx)?;
@@ -40,14 +43,26 @@ impl TransactionValidator {
             }
         }
         Self::check_sequence_lock(tx, pov_daa_score)?;
+        Self::check_fee_per_mass(fee, compute_mass, fee_per_mass_threshold)?;
         match flags {
             TxValidationFlags::Full | TxValidationFlags::SkipMassCheck => {
                 Self::check_sig_op_counts(tx)?;
                 self.check_scripts(tx)?;
             }
             TxValidationFlags::SkipScriptChecks => {}
         }
-        Ok(total_in - total_out)
+        Ok(fee)
+    }
+
+    fn check_fee_per_mass(fee: u64, mass: Option<u64>, threshold: Option<f64>) -> TxResult<()> {
+        // An actual check can only occur if both some mass and some threshold are provided,
+        // otherwise, the check does not verify anything and exits successfully.
+        if let (Some(compute_mass), Some(threshold)) = (mass, threshold) {
+            if fee as f64 / compute_mass as f64 <= threshold {
+                return Err(TxRuleError::FeePerMassTooLow);
+            }
+        }
+        Ok(())
     }
 
     fn check_transaction_coinbase_maturity(&self, tx: &impl VerifiableTransaction, pov_daa_score: u64) -> TxResult<()> {

mining/errors/src/mempool.rs

@@ -4,7 +4,7 @@ use kaspa_consensus_core::{
 };
 use thiserror::Error;
 
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum RuleError {
     /// A consensus transaction rule error
     ///
@@ -24,9 +24,15 @@ pub enum RuleError {
     #[error("transaction {0} is already in the mempool")]
     RejectDuplicate(TransactionId),
 
-    #[error("output {0} already spent by transaction {1} in the memory pool")]
+    #[error("output {0} already spent by transaction {1} in the mempool")]
     RejectDoubleSpendInMempool(TransactionOutpoint, TransactionId),
 
+    #[error("replace by fee found no double spending transaction in the mempool")]
+    RejectRbfNoDoubleSpend,
+
+    #[error("replace by fee found more than one double spending transaction in the mempool")]
+    RejectRbfTooManyDoubleSpendingTransactions,
+
     /// New behavior: a transaction is rejected if the mempool is full
     #[error("number of high-priority transactions in mempool ({0}) has reached the maximum allowed ({1})")]
     RejectMempoolIsFull(usize, u64),
@@ -95,7 +101,7 @@ impl From<TxRuleError> for RuleError {
 
 pub type RuleResult<T> = std::result::Result<T, RuleError>;
 
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum NonStandardError {
     #[error("transaction version {1} is not in the valid range of {2}-{3}")]
     RejectVersion(TransactionId, u16, u16, u16),