use core::{marker::PhantomData, pin::Pin, time::Duration};
use alloc::{boxed::Box, collections::BTreeMap};
use std::time::SystemTime;
use serai_db::{Get, Transaction as DbTxn, Db};
use ::tendermint::{Network, CommitFor, SlashReasonFor, InvalidBlock};
use crate::{
ReadWrite as _, ReadWriteAsBorsh,
transaction::Transaction,
block::{SyntacticError, SemanticError, EphemeralError, BlockError, Block},
Blockchain,
};
mod validator_set;
pub(crate) use validator_set::ValidatorSet;
mod signature_scheme;
pub use signature_scheme::*;
mod slash;
pub use slash::Slash;
mod block_proposal;
use block_proposal::BlockProposal;
impl<T: Transaction> ::tendermint::Block for ReadWriteAsBorsh<Block<T>> {
type Hash = [u8; 32];
fn proposal_hash(&self) -> Self::Hash {
use blake2::Digest as _;
let mut digest = blake2::Blake2b256::new();
self.0.write(crate::merkle::DigestWriter(&mut digest)).expect("`DigestWriter` is infallible");
digest.finalize().into()
}
fn semantic_hash(&self) -> Self::Hash {
self.0.hash()
}
}
pub type Commit = ::tendermint::Commit<AggregateSignature>;
pub(crate) trait Mempool<T> {
type Transactions: IntoIterator<Item = T>;
type Future: Future<Output = Self::Transactions>;
fn transactions(&mut self, parent_block: [u8; 32]) -> Self::Future;
fn censured(&self, getter: &impl Get, validator: [u8; 32]) -> bool;
fn censure(&mut self, txn: &mut impl DbTxn, validator: [u8; 32]);
}
mod db {
use super::*;
serai_db::schema!(TributaryTendermint {
PendingSlash: (genesis: [u8; 32], validator: [u8; 32]) -> ReadWriteAsBorsh<super::Slash>,
Commit: (genesis: [u8; 32], block: [u8; 32]) -> super::Commit,
});
}
pub(super) fn db_commit(getter: &impl Get, genesis: [u8; 32], block: [u8; 32]) -> Option<Commit> {
db::Commit::get(getter, genesis, block)
}
pub(crate) struct Tendermint<D, T: Transaction, M, N> {
genesis: [u8; 32],
_network: PhantomData<N>,
db: D,
blockchain: Blockchain<T>,
next_block_notification: async_channel::Receiver<async_channel::Sender<()>>,
slashes: BTreeMap<[u8; 32], Slash>,
mempool: M,
}
impl<D: Db, T: Transaction, M, N> Tendermint<D, T, M, N> {
pub(crate) fn new(
db: D,
genesis: [u8; 32],
blockchain: Blockchain<T>,
next_block_notification: async_channel::Receiver<async_channel::Sender<()>>,
mempool: M,
) -> Self {
let slashes = blockchain
.validator_set()
.as_ref()
.keys()
.copied()
.filter_map(|validator| {
db::PendingSlash::get(&db, genesis, validator).map(|slash| (validator, slash.0))
})
.collect::<BTreeMap<_, _>>();
Self {
genesis,
_network: PhantomData,
db,
blockchain,
next_block_notification,
slashes,
mempool,
}
}
}
impl<
D: Db,
T: Transaction,
M: Mempool<T>,
N: Network<[u8; 32], [u8; 64], AggregateSignature, ReadWriteAsBorsh<Block<T>>>,
> Tendermint<D, T, M, N>
{
pub(crate) fn block_proposal(
&mut self,
parent: [u8; 32],
minimum_time: Option<u64>,
weak_entropy: u64,
) -> Pin<Box<BlockProposal<N::Sleep, M::Future>>> {
Box::pin(match minimum_time {
Some(minimum_time) => BlockProposal::some::<T, N>(
self.genesis,
parent,
minimum_time,
self.slashes.clone(),
self.mempool.transactions(parent),
weak_entropy,
),
None => BlockProposal::none(),
})
}
}
trait FnOutput {
type Output;
}
impl<R> FnOutput for fn() -> R {
type Output = R;
}
type Never = <fn() -> ! as FnOutput>::Output;
type RWaB<T> = ReadWriteAsBorsh<T>;
impl<
D: Send + Db,
T: Send + Transaction,
M: Send + Mempool<T>,
N: Send + Network<[u8; 32], [u8; 64], AggregateSignature, RWaB<Block<T>>, Sleep: Send>,
> ::tendermint::Blockchain for Tendermint<D, T, M, N>
{
type Validator = [u8; 32];
type ValidatorSet = ValidatorSet;
type SignatureScheme = SignatureScheme;
type Genesis = [u8; 32];
type Block = ReadWriteAsBorsh<Block<T>>;
type BlockProposal = Pin<Box<BlockProposal<N::Sleep, M::Future>>>;
fn genesis(&self) -> &Self::Genesis {
&self.genesis
}
fn validator_set(&self) -> &Self::ValidatorSet {
self.blockchain.validator_set()
}
fn signature_scheme(&self) -> &Self::SignatureScheme {
self.blockchain.signature_scheme()
}
fn validate(
&mut self,
proposer: Self::Validator,
block: &Self::Block,
) -> impl Send + Future<Output = Result<(), InvalidBlock>> {
if self.blockchain.slashed(&self.db, proposer) {
return core::future::ready(Err(InvalidBlock::Fatal));
}
if self.slashes.contains_key(&proposer) || self.mempool.censured(&self.db, proposer) {
return core::future::ready(Err(InvalidBlock::Temporal));
}
core::future::ready(match self.blockchain.verify::<N>(&self.db, &block.0) {
Ok(()) => Ok(()),
Err(BlockError::Ephemeral(_)) => Err(InvalidBlock::Temporal),
Err(BlockError::Syntactic(_) | BlockError::Semantic(_)) => {
let mut txn = self.db.txn();
self.mempool.censure(&mut txn, proposer);
txn.commit();
Err(InvalidBlock::Fatal)
}
})
}
fn add_block(
&mut self,
ReadWriteAsBorsh(block): Self::Block,
commit: CommitFor<Self>,
) -> impl Send + Future<Output = Self::BlockProposal> {
let hash = block.hash();
let next_block_number = u64::from(commit.block_number()).checked_add(1);
let minimum_next_block_time = N::target_block_time()
.and_then(|target_block_time| u64::try_from(target_block_time.as_millis()).ok())
.and_then(|target_block_time| target_block_time.checked_add(block.time()));
#[expect(clippy::async_yields_async)]
async move {
let Some(next_block_number) = next_block_number else {
core::future::pending::<Never>().await
};
if Some(hash) == crate::blockchain::Reader::<T>::tip(&self.db, self.genesis) {
return self.block_proposal(hash, minimum_next_block_time, next_block_number);
}
match self.blockchain.verify::<N>(&self.db, &block) {
block_result @ (Ok(()) |
Err(
BlockError::Ephemeral(
EphemeralError::NotLocallyProvidedTransaction { .. } | EphemeralError::Future,
) |
BlockError::Semantic(SemanticError::DistinctProvided { .. }),
)) => {
if matches!(block_result, Err(BlockError::Ephemeral(EphemeralError::Future))) {
if let Some(minimum_next_block_time) = minimum_next_block_time &&
let Some(minimum_next_block_time) = SystemTime::UNIX_EPOCH
.checked_add(Duration::from_millis(minimum_next_block_time))
{
if let Ok(time_remaining) = minimum_next_block_time.duration_since(SystemTime::now())
{
N::sleep(time_remaining).await;
}
} else {
core::future::pending::<Never>().await;
}
}
{
let mut txn = self.db.txn();
for slash in block.slashes() {
if self.slashes.remove(slash.validator()).is_some() {
db::PendingSlash::del(&mut txn, self.genesis, *slash.validator());
}
}
self.blockchain.add(&mut txn, &block);
db::Commit::set(&mut txn, self.genesis, hash, &commit);
txn.commit();
}
while let Ok(next_block_notification) = self.next_block_notification.try_recv() {
let _ = next_block_notification.try_send(());
}
if let Some(minimum_next_block_time) = minimum_next_block_time &&
let Some(minimum_next_block_time) =
SystemTime::UNIX_EPOCH.checked_add(Duration::from_millis(minimum_next_block_time)) &&
let Ok(time_remaining) = minimum_next_block_time.duration_since(SystemTime::now())
{
N::sleep(time_remaining).await;
}
self.block_proposal(hash, minimum_next_block_time, next_block_number)
}
Err(
BlockError::Syntactic(
SyntacticError::ExceededSizeLimit { .. } |
SyntacticError::IncorrectContents |
SyntacticError::AbsurdTime |
SyntacticError::IncorrectOrderOfContents |
SyntacticError::Transaction(_),
) |
BlockError::Semantic(
SemanticError::TooSoon |
SemanticError::InvalidSlash { .. } |
SemanticError::SlashAlreadyIncluded { .. } |
SemanticError::UnsignedAlreadyIncluded { .. } |
SemanticError::InvalidSigner { .. } |
SemanticError::Gap { .. },
) |
BlockError::Ephemeral(EphemeralError::UnexpectedParent),
) => {
core::future::pending::<Never>().await
}
}
}
}
fn missed_proposal(&self, _proposer: Self::Validator) {}
fn slash(&mut self, validator: Self::Validator, slash_reason: SlashReasonFor<Self>) {
if self.blockchain.slashed(&self.db, validator) {
return;
}
let slash = Slash { validator, slash_reason };
let Ok(slash_size) = crate::serialized_len(&slash) else { return };
let existing_slash_size = self
.slashes
.get(slash.validator())
.and_then(|existing_slash| crate::serialized_len(existing_slash).ok());
let mut txn = self.db.txn();
if existing_slash_size.is_none() {
self.mempool.censure(&mut txn, *slash.validator());
}
if existing_slash_size.is_none_or(|existing_slash_size| existing_slash_size > slash_size) {
db::PendingSlash::set(&mut txn, self.genesis, *slash.validator(), (&slash).into());
self.slashes.insert(*slash.validator(), slash);
}
txn.commit();
}
}