use core::{
pin::Pin,
task::{Poll, Context},
};
use alloc::{boxed::Box, collections::BTreeSet};
use futures_core::stream::{Stream as _, FusedStream as _};
use serai_db::{Db, Get, Transaction as DbTxn};
use crate::transaction::{TransactionError, TransactionKind, Transaction};
serai_db::schema!(TributaryMempool {
LastBlock: (genesis: [u8; 32]) -> [u8; 32],
});
serai_db::channel!(TributaryMempool {
Censure: (genesis: [u8; 32]) -> [u8; 32],
});
#[derive(Clone, Debug)]
pub enum MempoolError {
Invalid(TransactionError),
AlreadyPresent,
Conflict,
RateLimit,
}
impl From<TransactionError> for MempoolError {
fn from(error: TransactionError) -> MempoolError {
MempoolError::Invalid(error)
}
}
mod provided;
use provided::*;
pub(crate) use provided::ProvidedReader;
mod un_signed;
use un_signed::*;
pub trait MempoolNetwork<T: Transaction> {
fn gossip(&mut self, genesis: [u8; 32], transaction: T);
}
impl<T: Transaction> MempoolNetwork<T> for () {
fn gossip(&mut self, _genesis: [u8; 32], _transaction: T) {}
}
pin_project_lite::pin_project! {
pub(crate) struct Mempool<D: Db, T: Transaction, N: MempoolNetwork<T>> {
db: D,
genesis: [u8; 32],
last_block: [u8; 32],
provided: Provided<T>,
un_signed: UnSigned<T>,
network: N,
regossip: usize,
#[pin]
censure: async_channel::Receiver<([u8; 32], async_channel::Sender<()>)>,
#[pin]
request: async_channel::Receiver<([u8; 32], async_channel::Sender<Box<[T]>>)>,
#[pin]
resend_request: async_channel::WeakSender<([u8; 32], async_channel::Sender<Box<[T]>>)>,
}
}
impl<D: Db, T: Transaction, N: MempoolNetwork<T>> Future for Mempool<D, T, N> {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut projection = self.project();
if let Some(block) =
crate::Reader::<T>::block_after(projection.db, *projection.genesis, *projection.last_block)
{
let block = crate::Reader::<T>::block(projection.db, *projection.genesis, block)
.expect("block after last block wasn't saved to database");
let mut txn = projection.db.txn();
LastBlock::set(&mut txn, *projection.genesis, &block.hash());
projection.provided.block(&mut txn, &block);
projection.un_signed.block(&mut txn, &block);
txn.commit();
*projection.last_block = block.hash();
{
let outstanding_un_signed_transactions = projection.un_signed.block_proposal().count();
let transactions_to_regossip = outstanding_un_signed_transactions.isqrt().isqrt().max(1);
if let Some(start) = projection.regossip.checked_rem(outstanding_un_signed_transactions) {
let end = start.saturating_add(transactions_to_regossip);
let range = start .. end;
for (i, transaction) in projection.un_signed.block_proposal().enumerate() {
if range.contains(&i) ||
i.checked_add(outstanding_un_signed_transactions)
.is_some_and(|i| range.contains(&i))
{
projection.network.gossip(*projection.genesis, transaction.clone());
}
}
*projection.regossip = projection.regossip.wrapping_add(transactions_to_regossip);
}
}
cx.waker().wake_by_ref();
return Poll::Pending;
}
while (!projection.censure.is_terminated()) &&
let Poll::Ready(Some((validator, response))) = projection.censure.as_mut().poll_next(cx)
{
let mut txn = projection.db.txn();
projection.un_signed.censure(&mut txn, validator);
txn.commit();
let _ = response.try_send(());
}
{
let mut txn = projection.db.txn();
while let Some(validator) = Censure::try_recv(&mut txn, *projection.genesis) {
projection.un_signed.censure(&mut txn, validator);
}
txn.commit();
}
if (!projection.request.is_terminated()) &&
let Poll::Ready(Some((parent, response))) = projection.request.poll_next(cx)
{
if parent == *projection.last_block {
let _ = response.try_send(
projection
.provided
.block_proposal()
.chain(projection.un_signed.block_proposal())
.cloned()
.collect::<Box<[_]>>(),
);
} else if let Some(resend_request) = projection.resend_request.upgrade() {
let _ = resend_request.try_send((parent, response));
}
}
Poll::Pending
}
}
pub(crate) struct MempoolConsumer<T> {
genesis: [u8; 32],
censured: BTreeSet<[u8; 32]>,
#[expect(clippy::type_complexity)]
request: async_channel::Sender<([u8; 32], async_channel::Sender<Box<[T]>>)>,
}
pin_project_lite::pin_project! {
pub(crate) struct MempoolRecv<T> {
#[pin]
receiver: Option<async_channel::Receiver<T>>
}
}
impl<T> Future for MempoolRecv<Box<[T]>> {
type Output = Box<[T]>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let message = if let Some(receiver) = self.project().receiver.as_pin_mut() {
let Poll::Ready(message) = receiver.poll_next(cx) else {
return Poll::Pending;
};
message
} else {
None
};
Poll::Ready(message.unwrap_or_else(Box::default))
}
}
impl<T: Transaction> crate::tendermint::Mempool<T> for MempoolConsumer<T> {
type Transactions = Box<[T]>;
type Future = MempoolRecv<Self::Transactions>;
fn transactions(&mut self, parent_block: [u8; 32]) -> Self::Future {
let (sender, receiver) = async_channel::bounded(1);
let sent_request = self.request.force_send((parent_block, sender));
MempoolRecv { receiver: sent_request.is_ok().then_some(receiver) }
}
fn censured(&self, getter: &impl Get, validator: [u8; 32]) -> bool {
self.censured.contains(&validator) || UnSigned::<T>::censured(getter, self.genesis, validator)
}
fn censure(&mut self, txn: &mut impl DbTxn, validator: [u8; 32]) {
if self.censured.insert(validator) {
Censure::send(txn, self.genesis, &validator);
}
}
}
impl<D: Db, T: Transaction, N: MempoolNetwork<T>> Mempool<D, T, N> {
pub(super) fn new(
mut db: D,
genesis: [u8; 32],
validators: impl IntoIterator<Item = [u8; 32]>,
network: N,
censure: async_channel::Receiver<([u8; 32], async_channel::Sender<()>)>,
rate_limit: usize,
) -> (Self, MempoolConsumer<T>) {
let last_block = LastBlock::get(&db, genesis).unwrap_or(genesis);
let provided = Provided::new(&db, genesis);
let un_signed = {
let mut txn = db.txn();
let mut un_signed = UnSigned::new(&mut txn, genesis, validators, rate_limit);
while let Some(validator) = Censure::try_recv(&mut txn, genesis) {
un_signed.censure(&mut txn, validator);
}
txn.commit();
un_signed
};
let (request_send, request_recv) = async_channel::bounded(1);
let resend_request = request_send.clone().downgrade();
(
Self {
db,
genesis,
last_block,
provided,
un_signed,
network,
regossip: 0,
censure,
request: request_recv,
resend_request,
},
MempoolConsumer {
genesis,
censured: BTreeSet::new(),
request: request_send,
},
)
}
pub(crate) fn add(
self: Pin<&mut Self>,
txn: &mut impl DbTxn,
transaction: T,
bypass_rate_limit: bool,
) -> Result<(), MempoolError> {
let projection = self.project();
match transaction.kind() {
TransactionKind::Provided { .. } => projection.provided.provide(txn, transaction),
TransactionKind::Unsigned | TransactionKind::Signed { .. } => {
let result = projection.un_signed.add(txn, transaction.clone(), bypass_rate_limit);
if result.is_ok() {
projection.network.gossip(*projection.genesis, transaction);
}
result
}
}
}
}