Roy/mempool

Cargo.toml

@@ -16,6 +16,7 @@ members = [
   "chainstate",    # code on chainstate of blocks and transactions
   "script",        # bitcoin script and its interfaces
   "logging",       # logging engine and its interfaces
+  "mempool",       # mempool interface and implementation
   "p2p",           # p2p communication interfaces and protocols
   "rpc",           # rpc abstraction and implementation
   "serialization", # full featured serialization interfaces and implementations
@@ -40,6 +41,7 @@ default-members = [
   "chainstate",
   "script",
   "logging",
+  "mempool",
   "p2p",
   "rpc",
   "serialization",
@@ -61,6 +63,7 @@ chainstate = { path = "chainstate"}
 chainstate-types = { path = "chainstate-types"}
 script = { path = "script"}
 logging = { path = "logging"}
+mempool = { path = "mempool"}
 p2p = { path = "p2p"}
 rpc = { path = "rpc"}
 serialization = { path = "serialization"}

common/src/chain/transaction.rs

@@ -17,6 +17,7 @@
 
 use crate::primitives::{Id, Idable};
 use serialization::{DirectDecode, DirectEncode, Encode};
+use thiserror::Error;
 
 use crate::chain::transaction::transaction_v1::TransactionV1;
 
@@ -54,8 +55,9 @@ impl Idable for Transaction {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Error, Debug, Clone)]
 pub enum TransactionCreationError {
+    #[error("An unknown error has occurred")]
     Unknown,
 }
 

common/src/chain/transaction/input.rs

@@ -52,6 +52,15 @@ impl From<Id<Genesis>> for OutPointSourceId {
     }
 }
 
+impl OutPointSourceId {
+    pub fn get_tx_id(&self) -> Option<&Id<Transaction>> {
+        match self {
+            OutPointSourceId::Transaction(id) => Some(id),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
 pub struct OutPoint {
     id: OutPointSourceId,

common/src/primitives/amount.rs

@@ -317,6 +317,35 @@ mod tests {
         assert_eq!(Amount { val: IntType::MAX } + Amount { val: 1 }, None);
     }
 
+    #[test]
+    fn sum_some() {
+        let amounts = vec![Amount { val: 1 }, Amount { val: 2 }, Amount { val: 3 }];
+        assert_eq!(
+            amounts.into_iter().sum::<Option<Amount>>(),
+            Some(Amount { val: 6 })
+        );
+    }
+
+    #[test]
+    fn sum_overflow() {
+        let amounts = vec![
+            Amount { val: 1 },
+            Amount { val: 2 },
+            Amount {
+                val: IntType::MAX - 2,
+            },
+        ];
+        assert_eq!(amounts.into_iter().sum::<Option<Amount>>(), None);
+    }
+
+    #[test]
+    fn sum_empty() {
+        assert_eq!(
+            vec![].into_iter().sum::<Option<Amount>>(),
+            Some(Amount::from_atoms(0))
+        )
+    }
+
     #[test]
     fn sub_underflow() {
         assert_eq!(Amount { val: IntType::MIN } - Amount { val: 1 }, None);

deny.toml

@@ -44,6 +44,7 @@ skip = [
     {name = "textwrap"},
     {name = "wasi"},
     {name = "winapi"},
+    {name = "windows"},
     {name = "windows_aarch64_msvc" },
     {name = "windows_i686_gnu" },
     {name = "windows_i686_msvc" },
@@ -70,6 +71,7 @@ allow = [
     "LicenseRef-webpki",
     "WTFPL",
     "BSL-1.0",
+    "Unicode-DFS-2016",
     "Unlicense",#this is a specific license rather than no license at all
 ] #deny a license not in this set of licenses
 

mempool/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "mempool"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+parity-scale-codec = {version = "3.1", features = ["derive", "chain-error"]}
+serialization = { path = '../serialization' }
+common = { path = '../common' }
+utils = { path = '../utils' }
+logging = { path = '../logging' }
+anyhow = "1.0"
+thiserror = "1.0"
+lazy_static = "1.4"
+mockall = "0.11.0"

mempool/src/error.rs

@@ -0,0 +1,71 @@
+use thiserror::Error;
+
+use common::chain::transaction::Transaction;
+use common::chain::OutPoint;
+use common::primitives::amount::Amount;
+use common::primitives::Id;
+use common::primitives::H256;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Mempool is full")]
+    MempoolFull,
+    #[error(transparent)]
+    TxValidationError(#[from] TxValidationError),
+}
+
+#[derive(Debug, Error)]
+pub enum TxValidationError {
+    #[error("Transaction has no inputs.")]
+    NoInputs,
+    #[error("Transaction has no outputs.")]
+    NoOutputs,
+    #[error("Transaction has duplicate inputs.")]
+    DuplicateInputs,
+    #[error("Outpoint not found: {outpoint:?}")]
+    OutPointNotFound {
+        outpoint: OutPoint,
+        tx_id: Id<Transaction>,
+    },
+    #[error("Transaction exceeds the maximum block size.")]
+    ExceedsMaxBlockSize,
+    #[error("Transaction already exists in the mempool.")]
+    TransactionAlreadyInMempool,
+    #[error("Transaction conflicts with another, irreplaceable transaction.")]
+    ConflictWithIrreplaceableTransaction,
+    #[error("The sum of the transaction's inputs' values overflows.")]
+    InputValuesOverflow,
+    #[error("The sum of the transaction's outputs' values overflows.")]
+    OutputValuesOverflow,
+    #[error("The sum of the transaction's inputs is smaller than the sum of its outputs.")]
+    InputsBelowOutputs,
+    #[error("Replacement transaction has fee lower than the original. Replacement fee is {replacement_fee:?}, original fee {original_fee:?}")]
+    ReplacementFeeLowerThanOriginal {
+        replacement_tx: H256,
+        replacement_fee: Amount,
+        original_tx: H256,
+        original_fee: Amount,
+    },
+    #[error("Transaction would require too many replacements.")]
+    TooManyPotentialReplacements,
+    #[error("Replacement transaction spends an unconfirmed input which was not spent by any of the original transactions.")]
+    SpendsNewUnconfirmedOutput,
+    #[error("The sum of the fees of this transaction's conflicts overflows.")]
+    ConflictsFeeOverflow,
+    #[error("Transaction pays a fee that is lower than the fee of its conflicts with their descendants.")]
+    TransactionFeeLowerThanConflictsWithDescendants,
+    #[error("Underflow in computing transaction's additional fees.")]
+    AdditionalFeesUnderflow,
+    #[error("Transaction does not pay sufficient fees to be relayed.")]
+    InsufficientFeesToRelay { tx_fee: Amount, relay_fee: Amount },
+    #[error("Replacement transaction does not pay enough for its bandwidth.")]
+    InsufficientFeesToRelayRBF,
+    #[error("Rolling fee threshold not met.")]
+    RollingFeeThresholdNotMet { minimum_fee: Amount, tx_fee: Amount },
+    #[error("Overflow encountered while updating ancestor fee.")]
+    AncestorFeeUpdateOverflow,
+    #[error("Transaction is a descendant of expired transaction.")]
+    DescendantOfExpiredTransaction,
+    #[error("Internal Error.")]
+    InternalError,
+}

mempool/src/feerate.rs

@@ -0,0 +1,76 @@
+use common::primitives::amount::Amount;
+
+lazy_static::lazy_static! {
+    pub(crate) static ref INCREMENTAL_RELAY_FEE_RATE: FeeRate = FeeRate::new(Amount::from_atoms(1000));
+    pub(crate) static ref INCREMENTAL_RELAY_THRESHOLD: FeeRate = FeeRate::new(Amount::from_atoms(500));
+}
+
+// TODO we should reconsider using Amount and define functions for the specific operations required
+// on FeeRate. Previous attempts to do this did not pan out, but this should be revisited to avoid
+// dangerous arithmetic operations
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) struct FeeRate {
+    atoms_per_kb: u128,
+}
+
+impl FeeRate {
+    pub(crate) fn new(atoms_per_kb: Amount) -> Self {
+        Self {
+            atoms_per_kb: atoms_per_kb.into_atoms(),
+        }
+    }
+
+    pub(crate) fn from_total_tx_fee(total_tx_fee: Amount, tx_size: usize) -> Self {
+        Self {
+            atoms_per_kb: Self::div_up(1000 * total_tx_fee.into_atoms(), tx_size),
+        }
+    }
+
+    pub(crate) fn compute_fee(&self, size: usize) -> Amount {
+        let size = u128::try_from(size).expect("compute_fee conversion");
+        // +999 for ceil operation
+        Amount::from_atoms((self.atoms_per_kb * size + 999) / 1000)
+    }
+
+    pub(crate) fn atoms_per_kb(&self) -> u128 {
+        self.atoms_per_kb
+    }
+
+    // TODO Use NonZeroUsize for divisor
+    fn div_up(dividend: u128, divisor: usize) -> u128 {
+        debug_assert!(divisor != 0);
+        let divisor = u128::try_from(divisor).expect("div_up conversion");
+        (dividend + divisor - 1) / divisor
+    }
+}
+
+impl std::ops::Add for FeeRate {
+    type Output = FeeRate;
+    fn add(self, other: Self) -> Self::Output {
+        let atoms_per_kb = self.atoms_per_kb + other.atoms_per_kb;
+        FeeRate { atoms_per_kb }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::num::NonZeroU128;
+
+    impl std::ops::Div<NonZeroU128> for FeeRate {
+        type Output = FeeRate;
+        fn div(self, rhs: NonZeroU128) -> Self::Output {
+            FeeRate {
+                atoms_per_kb: self.atoms_per_kb / rhs,
+            }
+        }
+    }
+
+    #[test]
+    fn test_div_up() {
+        let fee = 7;
+        let tx_size = usize::MAX;
+        let rate = FeeRate::div_up(fee, tx_size);
+        assert_eq!(rate, 1);
+    }
+}

mempool/src/lib.rs

@@ -0,0 +1,7 @@
+#![deny(clippy::clone_on_ref_ptr)]
+
+pub mod error;
+mod feerate;
+pub mod pool;
+
+pub use error::Error as MempoolError;