feat(mempool): add pending transaction type

crates/mempool/src/mempool.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use starknet_api::core::{ContractAddress, Nonce};
 use starknet_api::executable_transaction::Transaction;
-use starknet_api::transaction::{ResourceBoundsMapping, Tip, TransactionHash};
+use starknet_api::transaction::{Resource, ResourceBoundsMapping, Tip, TransactionHash};
 use starknet_mempool_types::errors::MempoolError;
 use starknet_mempool_types::mempool_types::{Account, AccountState, MempoolInput, MempoolResult};
 
@@ -227,4 +227,8 @@ impl TransactionReference {
             resource_bounds: ResourceBoundsMapping::default(),
         }
     }
+
+    pub fn get_l2_gas_price(&self) -> Option<u128> {
+        self.resource_bounds.0.get(&Resource::L2Gas).map(|bounds| bounds.max_price_per_unit)
+    }
 }

crates/mempool/src/transaction_queue.rs

@@ -68,21 +68,50 @@ impl TransactionQueue {
     }
 }
 
-/// Encapsulates a transaction reference to assess its order (i.e., priority).
+/// Encapsulates a transaction reference to assess its order (i.e., gas price).
+#[derive(Clone, Debug, derive_more::Deref, derive_more::From)]
+struct PendingTransaction(pub TransactionReference);
+
+/// Compare transactions based only on their gas price, using the Eq trait. It ensures that
+/// two gas price are either exactly equal or not.
+impl PartialEq for PendingTransaction {
+    fn eq(&self, other: &PendingTransaction) -> bool {
+        self.get_l2_gas_price() == other.get_l2_gas_price() && self.tx_hash == other.tx_hash
+    }
+}
+
+/// Marks this struct as capable of strict equality comparisons, signaling to the compiler it
+/// adheres to equality semantics.
+// Note: this depends on the implementation of `PartialEq`, see its docstring.
+impl Eq for PendingTransaction {}
+
+impl Ord for PendingTransaction {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.get_l2_gas_price()
+            .cmp(&other.get_l2_gas_price())
+            .then_with(|| self.tx_hash.cmp(&other.tx_hash))
+    }
+}
+
+impl PartialOrd for PendingTransaction {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// This struct behaves similarly to `PendingTransaction`, encapsulating a transaction reference
+/// to assess its order (i.e., tip).
+///
+/// # See also `PendingTransaction` docstring for details.
 #[derive(Clone, Debug, derive_more::Deref, derive_more::From)]
 struct PriorityTransaction(pub TransactionReference);
 
-/// Compare transactions based only on their tip, a uint, using the Eq trait. It ensures that two
-/// tips are either exactly equal or not.
 impl PartialEq for PriorityTransaction {
     fn eq(&self, other: &PriorityTransaction) -> bool {
         self.tip == other.tip && self.tx_hash == other.tx_hash
     }
 }
 
-/// Marks this struct as capable of strict equality comparisons, signaling to the compiler it
-/// adheres to equality semantics.
-// Note: this depends on the implementation of `PartialEq`, see its docstring.
 impl Eq for PriorityTransaction {}
 
 impl Ord for PriorityTransaction {