implement rpc method that fetches fee per mass based on block template

cli/src/modules/rpc.rs

@@ -229,6 +229,10 @@ impl Rpc {
                     }
                 }
             }
+            RpcApiOps::GetFeeInfo => {
+                let result = rpc.get_fee_info_call(GetFeeInfoRequest {}).await;
+                self.println(&ctx, result);
+            }
             _ => {
                 tprintln!(ctx, "rpc method exists but is not supported by the cli: '{op_str}'\r\n");
                 return Ok(());

consensus/core/src/block.rs

@@ -105,6 +105,8 @@ pub struct BlockTemplate {
     pub selected_parent_timestamp: u64,
     pub selected_parent_daa_score: u64,
     pub selected_parent_hash: Hash,
+    /// length one less than txs length due to lack of coinbase transaction
+    pub calculated_fees: Vec<u64>,
 }
 
 impl BlockTemplate {
@@ -115,8 +117,17 @@ impl BlockTemplate {
         selected_parent_timestamp: u64,
         selected_parent_daa_score: u64,
         selected_parent_hash: Hash,
+        calculated_fees: Vec<u64>,
     ) -> Self {
-        Self { block, miner_data, coinbase_has_red_reward, selected_parent_timestamp, selected_parent_daa_score, selected_parent_hash }
+        Self {
+            block,
+            miner_data,
+            coinbase_has_red_reward,
+            selected_parent_timestamp,
+            selected_parent_daa_score,
+            selected_parent_hash,
+            calculated_fees,
+        }
     }
 
     pub fn to_virtual_state_approx_id(&self) -> VirtualStateApproxId {

consensus/src/pipeline/virtual_processor/processor.rs

@@ -78,6 +78,7 @@ use kaspa_notify::{events::EventType, notifier::Notify};
 
 use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
 use itertools::Itertools;
+use kaspa_consensus_core::tx::ValidatedTransaction;
 use kaspa_utils::binary_heap::BinaryHeapExtensions;
 use parking_lot::{RwLock, RwLockUpgradableReadGuard};
 use rand::{seq::SliceRandom, Rng};
@@ -821,26 +822,24 @@ impl VirtualStateProcessor {
         txs: &[Transaction],
         virtual_state: &VirtualState,
         utxo_view: &V,
-    ) -> Vec<TxResult<()>> {
-        self.thread_pool.install(|| {
-            txs.par_iter()
-                .map(|tx| self.validate_block_template_transaction(tx, virtual_state, &utxo_view))
-                .collect::<Vec<TxResult<()>>>()
-        })
+    ) -> Vec<TxResult<u64>> {
+        self.thread_pool
+            .install(|| txs.par_iter().map(|tx| self.validate_block_template_transaction(tx, virtual_state, &utxo_view)).collect())
     }
 
     fn validate_block_template_transaction(
         &self,
         tx: &Transaction,
         virtual_state: &VirtualState,
         utxo_view: &impl UtxoView,
-    ) -> TxResult<()> {
+    ) -> TxResult<u64> {
         // No need to validate the transaction in isolation since we rely on the mining manager to submit transactions
         // which were previously validated through `validate_mempool_transaction_and_populate`, hence we only perform
         // in-context validations
         self.transaction_validator.utxo_free_tx_validation(tx, virtual_state.daa_score, virtual_state.past_median_time)?;
-        self.validate_transaction_in_utxo_context(tx, utxo_view, virtual_state.daa_score, TxValidationFlags::Full)?;
-        Ok(())
+        let ValidatedTransaction { calculated_fee, .. } =
+            self.validate_transaction_in_utxo_context(tx, utxo_view, virtual_state.daa_score, TxValidationFlags::Full)?;
+        Ok(calculated_fee)
     }
 
     pub fn build_block_template(
@@ -863,11 +862,17 @@ impl VirtualStateProcessor {
         let virtual_utxo_view = &virtual_read.utxo_set;
 
         let mut invalid_transactions = HashMap::new();
+        let mut calculated_fees = Vec::with_capacity(txs.len());
         let results = self.validate_block_template_transactions_in_parallel(&txs, &virtual_state, &virtual_utxo_view);
         for (tx, res) in txs.iter().zip(results) {
-            if let Err(e) = res {
-                invalid_transactions.insert(tx.id(), e);
-                tx_selector.reject_selection(tx.id());
+            match res {
+                Err(e) => {
+                    invalid_transactions.insert(tx.id(), e);
+                    tx_selector.reject_selection(tx.id());
+                }
+                Ok(fee) => {
+                    calculated_fees.push(fee);
+                }
             }
         }
 
@@ -882,12 +887,16 @@ impl VirtualStateProcessor {
             let next_batch_results =
                 self.validate_block_template_transactions_in_parallel(&next_batch, &virtual_state, &virtual_utxo_view);
             for (tx, res) in next_batch.into_iter().zip(next_batch_results) {
-                if let Err(e) = res {
-                    invalid_transactions.insert(tx.id(), e);
-                    tx_selector.reject_selection(tx.id());
-                    has_rejections = true;
-                } else {
-                    txs.push(tx);
+                match res {
+                    Err(e) => {
+                        invalid_transactions.insert(tx.id(), e);
+                        tx_selector.reject_selection(tx.id());
+                        has_rejections = true;
+                    }
+                    Ok(fee) => {
+                        txs.push(tx);
+                        calculated_fees.push(fee);
+                    }
                 }
             }
         }
@@ -904,7 +913,7 @@ impl VirtualStateProcessor {
         drop(virtual_read);
 
         // Build the template
-        self.build_block_template_from_virtual_state(virtual_state, miner_data, txs)
+        self.build_block_template_from_virtual_state(virtual_state, miner_data, txs, calculated_fees)
     }
 
     pub(crate) fn validate_block_template_transactions(
@@ -932,6 +941,7 @@ impl VirtualStateProcessor {
         virtual_state: Arc<VirtualState>,
         miner_data: MinerData,
         mut txs: Vec<Transaction>,
+        calculated_fees: Vec<u64>,
     ) -> Result<BlockTemplate, RuleError> {
         // [`calc_block_parents`] can use deep blocks below the pruning point for this calculation, so we
         // need to hold the pruning lock.
@@ -985,6 +995,7 @@ impl VirtualStateProcessor {
             selected_parent_timestamp,
             selected_parent_daa_score,
             selected_parent_hash,
+            calculated_fees,
         ))
     }
 

consensus/src/pipeline/virtual_processor/test_block_builder.rs

@@ -61,6 +61,6 @@ impl TestBlockBuilder {
         let pov_virtual_utxo_view = (&virtual_read.utxo_set).compose(accumulated_diff);
         self.validate_block_template_transactions(&txs, &pov_virtual_state, &pov_virtual_utxo_view)?;
         drop(virtual_read);
-        self.build_block_template_from_virtual_state(pov_virtual_state, miner_data, txs)
+        self.build_block_template_from_virtual_state(pov_virtual_state, miner_data, txs, vec![])
     }
 }

mining/src/lib.rs

@@ -33,6 +33,8 @@ pub struct MiningCounters {
     pub txs_sample: AtomicU64,
     pub orphans_sample: AtomicU64,
     pub accepted_sample: AtomicU64,
+
+    pub total_mass: AtomicU64,
 }
 
 impl Default for MiningCounters {
@@ -49,6 +51,7 @@ impl Default for MiningCounters {
             txs_sample: Default::default(),
             orphans_sample: Default::default(),
             accepted_sample: Default::default(),
+            total_mass: Default::default(),
         }
     }
 }
@@ -67,6 +70,7 @@ impl MiningCounters {
             txs_sample: self.txs_sample.load(Ordering::Relaxed),
             orphans_sample: self.orphans_sample.load(Ordering::Relaxed),
             accepted_sample: self.accepted_sample.load(Ordering::Relaxed),
+            total_mass: self.total_mass.load(Ordering::Relaxed),
         }
     }
 
@@ -102,6 +106,7 @@ pub struct MempoolCountersSnapshot {
     pub txs_sample: u64,
     pub orphans_sample: u64,
     pub accepted_sample: u64,
+    pub total_mass: u64,
 }
 
 impl MempoolCountersSnapshot {
@@ -157,6 +162,7 @@ impl core::ops::Sub for &MempoolCountersSnapshot {
             txs_sample: (self.txs_sample + rhs.txs_sample) / 2,
             orphans_sample: (self.orphans_sample + rhs.orphans_sample) / 2,
             accepted_sample: (self.accepted_sample + rhs.accepted_sample) / 2,
+            total_mass: self.total_mass.checked_sub(rhs.total_mass).unwrap_or_default(),
         }
     }
 }

mining/src/mempool/remove_transaction.rs

@@ -6,6 +6,7 @@ use crate::mempool::{
 use kaspa_consensus_core::tx::TransactionId;
 use kaspa_core::{debug, warn};
 use kaspa_utils::iter::IterExtensions;
+use std::sync::atomic::Ordering;
 
 impl Mempool {
     pub(crate) fn remove_transaction(
@@ -33,6 +34,7 @@ impl Mempool {
         for tx_id in removed_transactions.iter() {
             // Remove the tx from the transaction pool and the UTXO set (handled within the pool)
             let tx = self.transaction_pool.remove_transaction(tx_id)?;
+            self.counters.total_mass.fetch_sub(tx.mtx.tx.mass(), Ordering::Relaxed);
             // Update/remove descendent orphan txs (depending on `remove_redeemers`)
             let txs = self.orphan_pool.update_orphans_after_transaction_removed(&tx, remove_redeemers)?;
             removed_orphans.extend(txs.into_iter().map(|x| x.id()));

mining/src/mempool/validate_and_insert_transaction.rs

@@ -13,6 +13,7 @@ use kaspa_consensus_core::{
     tx::{MutableTransaction, Transaction, TransactionId, TransactionOutpoint, UtxoEntry},
 };
 use kaspa_core::{debug, info};
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
 impl Mempool {
@@ -78,6 +79,7 @@ impl Mempool {
         // Add the transaction to the mempool as a MempoolTransaction and return a clone of the embedded Arc<Transaction>
         let accepted_transaction =
             self.transaction_pool.add_transaction(transaction, consensus.get_virtual_daa_score(), priority)?.mtx.tx.clone();
+        self.counters.total_mass.fetch_add(accepted_transaction.mass(), Ordering::Relaxed);
         Ok(Some(accepted_transaction))
     }
 

mining/src/testutils/consensus_mock.rs

@@ -100,7 +100,7 @@ impl ConsensusApi for ConsensusMock {
         );
         let mutable_block = MutableBlock::new(header, txs);
 
-        Ok(BlockTemplate::new(mutable_block, miner_data, coinbase.has_red_reward, now, 0, ZERO_HASH))
+        Ok(BlockTemplate::new(mutable_block, miner_data, coinbase.has_red_reward, now, 0, ZERO_HASH, vec![]))
     }
 
     fn validate_mempool_transaction(&self, mutable_tx: &mut MutableTransaction) -> TxResult<()> {

rpc/core/src/api/ops.rs

@@ -86,6 +86,8 @@ pub enum RpcApiOps {
     GetCoinSupply,
     /// Get DAA Score timestamp estimate
     GetDaaScoreTimestampEstimate,
+    /// Get priority fee estimate
+    GetFeeInfo,
 
     // Subscription commands for starting/stopping notifications
     NotifyBlockAdded,

rpc/core/src/api/rpc.rs

@@ -304,6 +304,11 @@ pub trait RpcApi: Sync + Send + AnySync {
         request: GetDaaScoreTimestampEstimateRequest,
     ) -> RpcResult<GetDaaScoreTimestampEstimateResponse>;
 
+    async fn get_fee_info(&self) -> RpcResult<GetFeeInfoResponse> {
+        self.get_fee_info_call(GetFeeInfoRequest {}).await
+    }
+    async fn get_fee_info_call(&self, request: GetFeeInfoRequest) -> RpcResult<GetFeeInfoResponse>;
+
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Notification API
 

rpc/core/src/model/message.rs

@@ -825,6 +825,37 @@ impl GetDaaScoreTimestampEstimateResponse {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetFeeInfoRequest {}
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VirtualFeePerMass {
+    pub max: f64,
+    pub median: f64,
+    pub min: f64,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum FeePerMass {
+    VirtualFeePerMass(VirtualFeePerMass),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetFeeInfoResponse {
+    pub fee_per_mass: FeePerMass,
+    pub mempool_total_mass: u64,
+}
+
+impl GetFeeInfoResponse {
+    pub fn new(fee_per_mass: FeePerMass, mempool_total_mass: u64) -> Self {
+        Self { fee_per_mass, mempool_total_mass }
+    }
+}
+
 // ----------------------------------------------------------------------------
 // Subscriptions & notifications
 // ----------------------------------------------------------------------------

rpc/grpc/client/src/lib.rs

@@ -271,6 +271,7 @@ impl RpcApi for GrpcClient {
     route!(get_mempool_entries_by_addresses_call, GetMempoolEntriesByAddresses);
     route!(get_coin_supply_call, GetCoinSupply);
     route!(get_daa_score_timestamp_estimate_call, GetDaaScoreTimestampEstimate);
+    route!(get_fee_info_call, GetFeeInfo);
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Notification API

rpc/grpc/core/proto/messages.proto

@@ -59,6 +59,7 @@ message KaspadRequest {
     GetServerInfoRequestMessage getServerInfoRequest = 1092;
     GetSyncStatusRequestMessage getSyncStatusRequest = 1094;
     GetDaaScoreTimestampEstimateRequestMessage GetDaaScoreTimestampEstimateRequest = 1096;
+    GetFeeInfoRequestMessage getFeeInfoRequest = 1098;
   }
 }
 
@@ -118,6 +119,7 @@ message KaspadResponse {
     GetServerInfoResponseMessage getServerInfoResponse = 1093;
     GetSyncStatusResponseMessage getSyncStatusResponse = 1095;
     GetDaaScoreTimestampEstimateResponseMessage GetDaaScoreTimestampEstimateResponse = 1097;
+    GetFeeInfoResponseMessage getFeeInfoResponse = 1099;
   }
 }
 

rpc/grpc/core/proto/rpc.proto

@@ -851,3 +851,19 @@ message GetDaaScoreTimestampEstimateResponseMessage{
         repeated uint64 timestamps = 1;
         RPCError error = 1000;
 }
+
+message GetFeeInfoRequestMessage {}
+
+message GetFeeInfoResponseMessage {
+  oneof fee_per_mass {
+    Virtual virtual = 2; // 1 is reserved for `All`
+  }
+  uint64 mempool_total_mass = 11;
+  RPCError error = 1000;
+}
+
+message Virtual {
+  double max = 1;
+  double median = 2;
+  double min = 3;
+}

rpc/grpc/core/src/convert/kaspad.rs

@@ -57,6 +57,7 @@ pub mod kaspad_request_convert {
     impl_into_kaspad_request!(GetServerInfo);
     impl_into_kaspad_request!(GetSyncStatus);
     impl_into_kaspad_request!(GetDaaScoreTimestampEstimate);
+    impl_into_kaspad_request!(GetFeeInfo);
 
     impl_into_kaspad_request!(NotifyBlockAdded);
     impl_into_kaspad_request!(NotifyNewBlockTemplate);
@@ -188,6 +189,7 @@ pub mod kaspad_response_convert {
     impl_into_kaspad_response!(GetServerInfo);
     impl_into_kaspad_response!(GetSyncStatus);
     impl_into_kaspad_response!(GetDaaScoreTimestampEstimate);
+    impl_into_kaspad_response!(GetFeeInfo);
 
     impl_into_kaspad_notify_response!(NotifyBlockAdded);
     impl_into_kaspad_notify_response!(NotifyNewBlockTemplate);