use std::collections::BTreeSet;
use serde::{Deserialize, Serialize};
use crate::{
domain::{
ExactDecimal,
bitcoin::{Satoshis, Txid},
},
error::{Error, ValidationError},
};
fn invalid() -> Error {
ValidationError::InvalidMempoolRecord.into()
}
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(try_from = "ExactDecimal", into = "ExactDecimal")]
pub struct FeeRate(ExactDecimal);
impl FeeRate {
pub fn new(value: ExactDecimal) -> Result<Self, Error> {
if value.is_negative() {
return Err(invalid());
}
Ok(Self(value))
}
pub fn parse(value: &str) -> Result<Self, Error> {
Self::new(ExactDecimal::parse(value).map_err(|_| invalid())?)
}
#[must_use]
pub const fn value(&self) -> &ExactDecimal {
&self.0
}
}
impl TryFrom<ExactDecimal> for FeeRate {
type Error = Error;
fn try_from(value: ExactDecimal) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<FeeRate> for ExactDecimal {
fn from(value: FeeRate) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ExactDecimal", into = "ExactDecimal")]
pub struct VirtualSize(ExactDecimal);
impl VirtualSize {
pub fn new(value: ExactDecimal) -> Result<Self, Error> {
let quarter_increment = value
.canonical()
.split_once('.')
.is_none_or(|(_, fraction)| matches!(fraction, "25" | "5" | "75"));
if value.is_negative()
|| value.is_zero()
|| !quarter_increment
|| value > ExactDecimal::parse("1000000")?
{
return Err(invalid());
}
Ok(Self(value))
}
#[must_use]
pub const fn value(&self) -> &ExactDecimal {
&self.0
}
}
impl TryFrom<ExactDecimal> for VirtualSize {
type Error = Error;
fn try_from(value: ExactDecimal) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<VirtualSize> for ExactDecimal {
fn from(value: VirtualSize) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FeeHistogramBin {
lower_rate: FeeRate,
virtual_bytes: u64,
}
impl FeeHistogramBin {
#[must_use]
pub const fn new(lower_rate: FeeRate, virtual_bytes: u64) -> Self {
Self {
lower_rate,
virtual_bytes,
}
}
#[must_use]
pub const fn lower_rate(&self) -> &FeeRate {
&self.lower_rate
}
#[must_use]
pub const fn virtual_bytes(&self) -> u64 {
self.virtual_bytes
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SummaryFields")]
pub struct MempoolSummary {
transaction_count: u64,
virtual_bytes: u64,
total_fee: Satoshis,
histogram: Vec<FeeHistogramBin>,
}
impl MempoolSummary {
pub const MAX_HISTOGRAM_BINS: usize = 100_000;
pub fn new(
transaction_count: u64,
virtual_bytes: u64,
total_fee: Satoshis,
histogram: Vec<FeeHistogramBin>,
) -> Result<Self, Error> {
let sum = histogram
.iter()
.try_fold(0_u64, |sum, bin| sum.checked_add(bin.virtual_bytes()));
if histogram.len() > Self::MAX_HISTOGRAM_BINS
|| histogram
.windows(2)
.any(|bins| bins[0].lower_rate() <= bins[1].lower_rate())
|| sum.is_none_or(|sum| sum > virtual_bytes)
|| (transaction_count == 0
&& (virtual_bytes != 0 || total_fee.raw() != 0 || !histogram.is_empty()))
|| (transaction_count != 0 && virtual_bytes == 0)
{
return Err(invalid());
}
Ok(Self {
transaction_count,
virtual_bytes,
total_fee,
histogram,
})
}
#[must_use]
pub const fn transaction_count(&self) -> u64 {
self.transaction_count
}
#[must_use]
pub const fn virtual_bytes(&self) -> u64 {
self.virtual_bytes
}
#[must_use]
pub const fn total_fee(&self) -> Satoshis {
self.total_fee
}
#[must_use]
pub fn histogram(&self) -> &[FeeHistogramBin] {
&self.histogram
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SummaryFields {
transaction_count: u64,
virtual_bytes: u64,
total_fee: Satoshis,
histogram: Vec<FeeHistogramBin>,
}
impl TryFrom<SummaryFields> for MempoolSummary {
type Error = Error;
fn try_from(v: SummaryFields) -> Result<Self, Error> {
Self::new(
v.transaction_count,
v.virtual_bytes,
v.total_fee,
v.histogram,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RecentFields")]
pub struct RecentTransaction {
txid: Txid,
fee: Satoshis,
virtual_size: VirtualSize,
output_value: Satoshis,
}
impl RecentTransaction {
pub fn new(
txid: Txid,
fee: Satoshis,
virtual_size: VirtualSize,
output_value: Satoshis,
) -> Result<Self, Error> {
if output_value
.raw()
.checked_add(fee.raw())
.is_none_or(|sum| sum > bitcoin::Amount::MAX_MONEY.to_sat())
{
return Err(invalid());
}
Ok(Self {
txid,
fee,
virtual_size,
output_value,
})
}
#[must_use]
pub const fn txid(&self) -> Txid {
self.txid
}
#[must_use]
pub const fn fee(&self) -> Satoshis {
self.fee
}
#[must_use]
pub const fn virtual_size(&self) -> &VirtualSize {
&self.virtual_size
}
#[must_use]
pub const fn output_value(&self) -> Satoshis {
self.output_value
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RecentFields {
txid: Txid,
fee: Satoshis,
virtual_size: VirtualSize,
output_value: Satoshis,
}
impl TryFrom<RecentFields> for RecentTransaction {
type Error = Error;
fn try_from(v: RecentFields) -> Result<Self, Error> {
Self::new(v.txid, v.fee, v.virtual_size, v.output_value)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "Vec<RecentTransaction>", into = "Vec<RecentTransaction>")]
pub struct RecentTransactions(Vec<RecentTransaction>);
impl RecentTransactions {
pub const MAX_ENTRIES: usize = 10;
pub fn new(values: Vec<RecentTransaction>) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if values.len() > Self::MAX_ENTRIES || values.iter().any(|value| !ids.insert(value.txid()))
{
return Err(invalid());
}
Ok(Self(values))
}
#[must_use]
pub fn transactions(&self) -> &[RecentTransaction] {
&self.0
}
}
impl TryFrom<Vec<RecentTransaction>> for RecentTransactions {
type Error = Error;
fn try_from(v: Vec<RecentTransaction>) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<RecentTransactions> for Vec<RecentTransaction> {
fn from(v: RecentTransactions) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "u32", into = "u32")]
pub struct TransactionLimit(u32);
impl TransactionLimit {
pub const MAXIMUM: u32 = 100_000;
pub fn new(value: u32) -> Result<Self, Error> {
if value == 0 || value > Self::MAXIMUM {
return Err(ValidationError::InvalidPageRequest.into());
}
Ok(Self(value))
}
#[must_use]
pub const fn get(self) -> u32 {
self.0
}
}
impl TryFrom<u32> for TransactionLimit {
type Error = Error;
fn try_from(v: u32) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<TransactionLimit> for u32 {
fn from(v: TransactionLimit) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "IdsFields")]
pub struct TransactionIds {
limit: TransactionLimit,
txids: Vec<Txid>,
}
impl TransactionIds {
pub fn new(limit: TransactionLimit, txids: Vec<Txid>) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if txids.len() > limit.get() as usize || txids.iter().any(|id| !ids.insert(*id)) {
return Err(invalid());
}
Ok(Self { limit, txids })
}
#[must_use]
pub const fn limit(&self) -> TransactionLimit {
self.limit
}
#[must_use]
pub fn txids(&self) -> &[Txid] {
&self.txids
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct IdsFields {
limit: TransactionLimit,
txids: Vec<Txid>,
}
impl TryFrom<IdsFields> for TransactionIds {
type Error = Error;
fn try_from(v: IdsFields) -> Result<Self, Error> {
Self::new(v.limit, v.txids)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RecommendedFees {
fastest: FeeRate,
half_hour: FeeRate,
hour: FeeRate,
economy: FeeRate,
minimum: FeeRate,
}
impl RecommendedFees {
#[must_use]
pub const fn new(
fastest: FeeRate,
half_hour: FeeRate,
hour: FeeRate,
economy: FeeRate,
minimum: FeeRate,
) -> Self {
Self {
fastest,
half_hour,
hour,
economy,
minimum,
}
}
#[must_use]
pub const fn fastest(&self) -> &FeeRate {
&self.fastest
}
#[must_use]
pub const fn half_hour(&self) -> &FeeRate {
&self.half_hour
}
#[must_use]
pub const fn hour(&self) -> &FeeRate {
&self.hour
}
#[must_use]
pub const fn economy(&self) -> &FeeRate {
&self.economy
}
#[must_use]
pub const fn minimum(&self) -> &FeeRate {
&self.minimum
}
}