use core::time::Duration;
use alloc::boxed::Box;
use std::{io, time::SystemTime};
use blake2::{digest::Digest as _, Blake2b256};
use crate::{
ReadWrite, Slash,
transaction::{TransactionError, Signed, TransactionKind, Transaction},
};
#[derive(Clone, Debug)]
pub enum SyntacticError {
ExceededSizeLimit {
size: Option<usize>,
},
IncorrectContents,
AbsurdTime,
IncorrectOrderOfContents,
Transaction(TransactionError),
}
impl From<TransactionError> for SyntacticError {
fn from(error: TransactionError) -> SyntacticError {
SyntacticError::Transaction(error)
}
}
#[derive(Clone, Debug)]
pub enum SemanticError {
TooSoon,
InvalidSlash {
validator: [u8; 32],
},
SlashAlreadyIncluded {
validator: [u8; 32],
},
DistinctProvided {
scope: &'static str,
transaction_hash: [u8; 32],
expected_hash: [u8; 32],
},
UnsignedAlreadyIncluded {
transaction_hash: [u8; 32],
},
InvalidSigner {
signer: [u8; 32],
},
Gap {
transaction_hash: [u8; 32],
transaction_nonce: u64,
expected_nonce: Option<u64>,
},
}
#[derive(Clone, Debug)]
pub enum EphemeralError {
UnexpectedParent,
Future,
NotLocallyProvidedTransaction {
scope: &'static str,
transaction_hash: [u8; 32],
},
}
#[derive(Clone, Debug)]
pub enum BlockError {
Syntactic(SyntacticError),
Semantic(SemanticError),
Ephemeral(EphemeralError),
}
impl From<SyntacticError> for BlockError {
fn from(error: SyntacticError) -> BlockError {
BlockError::Syntactic(error)
}
}
impl From<TransactionError> for BlockError {
fn from(error: TransactionError) -> BlockError {
BlockError::from(SyntacticError::from(error))
}
}
impl From<SemanticError> for BlockError {
fn from(error: SemanticError) -> BlockError {
BlockError::Semantic(error)
}
}
impl From<EphemeralError> for BlockError {
fn from(error: EphemeralError) -> BlockError {
BlockError::Ephemeral(error)
}
}
#[derive(Clone, Copy, Debug)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct BlockHeader {
parent: [u8; 32],
time: u64,
slashes: [u8; 32],
transactions: [u8; 32],
}
impl ReadWrite for BlockHeader {
fn read(mut reader: impl io::Read) -> io::Result<Self> {
let parent = {
let mut parent = [0; 32];
reader.read_exact(&mut parent)?;
parent
};
let time = {
let mut time = [0; 8];
reader.read_exact(&mut time)?;
u64::from_le_bytes(time)
};
let slashes = {
let mut slashes = [0; 32];
reader.read_exact(&mut slashes)?;
slashes
};
let transactions = {
let mut transactions = [0; 32];
reader.read_exact(&mut transactions)?;
transactions
};
Ok(Self { parent, time, slashes, transactions })
}
fn write(&self, mut writer: impl io::Write) -> io::Result<()> {
let Self { parent, time, slashes, transactions } = self;
writer.write_all(parent)?;
writer.write_all(&time.to_le_bytes())?;
writer.write_all(slashes)?;
writer.write_all(transactions)
}
}
impl crate::merkle::Digestible for BlockHeader {
fn update(&self, digest: &mut (impl ?Sized + blake2::digest::Update)) {
self.write(crate::merkle::DigestWriter(digest)).expect("`DigestWriter` is infallible");
}
}
impl BlockHeader {
const SIZE: usize = 32 + 8 + 32 + 32;
pub fn parent(&self) -> [u8; 32] {
self.parent
}
pub fn time(&self) -> u64 {
self.time
}
pub fn slashes(&self) -> [u8; 32] {
self.slashes
}
pub fn transactions(&self) -> [u8; 32] {
self.transactions
}
pub fn hash(&self) -> [u8; 32] {
crate::merkle::Digestible::chain_update(self, Blake2b256::new()).finalize().into()
}
}
#[derive(Clone, Debug)]
pub struct Block<T: Transaction> {
header: BlockHeader,
slashes: Box<[Slash]>,
transactions: Box<[T]>,
}
impl<T: Transaction> ReadWrite for Block<T> {
fn read(mut reader: impl io::Read) -> io::Result<Self> {
let header = BlockHeader::read(&mut reader)?;
let slashes = (0 .. {
let mut slashes = [0; 2];
reader.read_exact(&mut slashes)?;
u16::from_le_bytes(slashes)
})
.map(|_| Slash::read(&mut reader))
.collect::<Result<Box<[_]>, _>>()?;
let transactions = (0 .. {
let mut transactions = [0; 4];
reader.read_exact(&mut transactions)?;
u32::from_le_bytes(transactions)
})
.map(|_| T::read(&mut reader))
.collect::<Result<Box<[_]>, _>>()?;
Ok(Block { header, slashes, transactions })
}
fn write(&self, mut writer: impl io::Write) -> io::Result<()> {
let Block { header, slashes, transactions } = self;
header.write(&mut writer)?;
writer.write_all(
&u16::try_from(slashes.len())
.map_err(|_| io::Error::other("block has more slashes than validators"))?
.to_le_bytes(),
)?;
for slash in slashes {
slash.write(&mut writer)?;
}
writer.write_all(
&u32::try_from(transactions.len())
.map_err(|_| io::Error::other("block has more than four billion transactions"))?
.to_le_bytes(),
)?;
for tx in transactions {
tx.write(&mut writer)?;
}
Ok(())
}
}
impl<T: Transaction> Block<T> {
pub(crate) const EMPTY_BLOCK_SIZE: usize = BlockHeader::SIZE + 2 + 4;
pub(crate) fn system_time(&self) -> Result<SystemTime, SyntacticError> {
let Some(time) = SystemTime::UNIX_EPOCH.checked_add(Duration::from_millis(self.time())) else {
Err(SyntacticError::AbsurdTime)?
};
Ok(time)
}
fn verify_syntax_slashes<'block>(
slashes: impl IntoIterator<Item = &'block Slash>,
) -> Result<(), SyntacticError> {
slashes
.into_iter()
.is_sorted_by(|a, b| a.validator() < b.validator())
.ok_or(SyntacticError::IncorrectOrderOfContents)
}
fn verify_syntax_transactions<'block>(
genesis: [u8; 32],
transactions: impl IntoIterator<Item = &'block T>,
) -> Result<(), SyntacticError>
where
T: 'block,
{
#[expect(clippy::type_complexity)]
let mut order: (
u8,
Option<&'static [u8]>,
Option<[u8; 32]>,
Option<([u8; 32], Box<[u8]>, u64)>,
) = (0, None, None, None);
for transaction in transactions {
let new_order = match transaction.kind() {
TransactionKind::Provided { scope } => (0, Some(scope.as_bytes()), None, None),
TransactionKind::Unsigned => (1, None, Some(transaction.hash()), None),
TransactionKind::Signed { scope, signed: Signed { signer, nonce, signature: _ } } => {
if let Some((prior_signer, ref prior_scope, prior_nonce)) = order.3 &&
(prior_signer == signer) &&
(prior_scope == &scope) &&
(prior_nonce.checked_add(1) != Some(nonce))
{
Err(SyntacticError::IncorrectOrderOfContents)?;
}
(2, None, None, Some((signer, scope, nonce)))
}
};
if order.0 == 0 {
if new_order < order {
Err(SyntacticError::IncorrectOrderOfContents)?;
}
} else if new_order <= order {
Err(SyntacticError::IncorrectOrderOfContents)?;
}
order = new_order;
crate::transaction::verify_syntax(transaction, genesis)?;
}
Ok(())
}
pub fn verify_syntax(&self, genesis: [u8; 32]) -> Result<(), SyntacticError> {
if self.transactions.len() >
const {
#[expect(clippy::eq_op, clippy::manual_assert)]
if 4_294_967_295 != u32::MAX {
panic!("inlined `u32::MAX` constant wasn't correct");
}
4_294_967_295
}
{
Err(SyntacticError::ExceededSizeLimit { size: None })?;
}
if let Some(block_size_limit) = T::BLOCK_SIZE_LIMIT {
let Ok(serialized_len) = crate::serialized_len(self) else {
Err(SyntacticError::ExceededSizeLimit { size: None })?
};
if serialized_len > block_size_limit {
Err(SyntacticError::ExceededSizeLimit { size: Some(serialized_len) })?;
}
}
if (self.header.slashes != crate::merkle::root::<Slash>(self.slashes.iter())) ||
(self.header.transactions != crate::merkle::root::<T>(self.transactions.iter()))
{
Err(SyntacticError::IncorrectContents)?;
}
self.system_time()?;
Self::verify_syntax_slashes(&self.slashes)?;
Self::verify_syntax_transactions(genesis, &self.transactions)?;
Ok(())
}
pub fn instantiate(
genesis: [u8; 32],
parent: [u8; 32],
time: u64,
slashes: Box<[Slash]>,
transactions: Box<[T]>,
) -> Result<Self, SyntacticError> {
let block = Block {
header: BlockHeader {
parent,
time,
slashes: crate::merkle::root::<Slash>(slashes.iter()),
transactions: crate::merkle::root::<T>(transactions.iter()),
},
slashes,
transactions,
};
block.verify_syntax(genesis)?;
Ok(block)
}
pub fn parent(&self) -> [u8; 32] {
self.header.parent
}
pub fn time(&self) -> u64 {
self.header.time
}
pub fn hash(&self) -> [u8; 32] {
self.header.hash()
}
pub fn slashes(&self) -> &[Slash] {
&self.slashes
}
pub fn transactions(&self) -> &[T] {
&self.transactions
}
}
#[test]
fn sizes() {
use crate::transaction::TestTransaction;
let header = BlockHeader {
parent: [0xaa; 32],
time: u64::MAX,
slashes: [0xbb; 32],
transactions: [0xcc; 32],
};
assert_eq!(header, BlockHeader::read(&mut header.serialize().as_slice()).unwrap());
assert_eq!(header.serialize().len(), BlockHeader::SIZE);
assert_eq!(
(Block::<TestTransaction> { header, slashes: Box::default(), transactions: Box::default() })
.serialize()
.len(),
Block::<TestTransaction>::EMPTY_BLOCK_SIZE
);
}
#[test]
fn slashes() {
use crate::transaction::TestTransaction;
let slash = |validator: [u8; 32]| {
let mut slash = validator.to_vec();
loop {
if let Ok(slash) = Slash::read(&mut slash.as_slice()) {
return slash;
}
slash.push(1);
assert!(slash.len() < (32 * 1_024), "32 KiB slash still couldn't be deserialized");
}
};
Block::<TestTransaction>::verify_syntax_slashes([&slash([0xaa; 32])]).expect("one slash");
Block::<TestTransaction>::verify_syntax_slashes([&slash([0xaa; 32]), &slash([0xbb; 32])])
.expect("sorted");
Block::<TestTransaction>::verify_syntax_slashes([&slash([0xaa; 32]), &slash([0xaa; 32])])
.expect_err("multiple inclusions");
Block::<TestTransaction>::verify_syntax_slashes([&slash([0xbb; 32]), &slash([0xaa; 32])])
.expect_err("not sorted");
}
#[test]
fn transactions() {
use core::ops::Deref as _;
use zeroize::Zeroizing;
use rand::rngs::OsRng;
use ciphersuite::{
group::{ff::PrimeField as _, GroupEncoding as _},
Ciphersuite,
};
use dalek_ff_group::Ristretto;
use crate::transaction::TestTransaction;
let genesis = [0xfe; 32];
let (alice, bob) = {
let alice = Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng));
let bob = Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng));
if (<Ristretto as Ciphersuite>::generator() * alice.deref()).to_bytes() <
(<Ristretto as Ciphersuite>::generator() * bob.deref()).to_bytes()
{
(alice, bob)
} else {
(bob, alice)
}
};
let transaction = |(mut kind, salt)| {
let mut key = None;
let nonce = <Ristretto as Ciphersuite>::F::random(&mut OsRng);
if let TransactionKind::Signed { scope: _, signed: Signed { signer, nonce: _, signature } } =
&mut kind
{
let key_value = if *signer == [0xaa; 32] {
&alice
} else if *signer == [0xbb; 32] {
&bob
} else {
panic!()
};
*signer = (<Ristretto as Ciphersuite>::generator() * key_value.deref()).to_bytes();
key = Some(key_value);
signature[.. 32]
.copy_from_slice((<Ristretto as Ciphersuite>::generator() * nonce).to_bytes().as_ref());
}
let mut transaction = TestTransaction { valid: true, kind, salt };
if let Some(signature_challenge) = transaction.signature_challenge(genesis) {
let TransactionKind::Signed { scope: _, signed: Signed { signer: _, nonce: _, signature } } =
&mut transaction.kind
else {
panic!("signature challenge but not signed")
};
let s = nonce + (signature_challenge * key.unwrap().deref());
signature[32 ..].copy_from_slice(s.to_repr().as_ref());
}
transaction
};
let provided = [
(TransactionKind::Provided { scope: "provided 0" }, 1),
(TransactionKind::Provided { scope: "provided 0" }, 0),
(TransactionKind::Provided { scope: "provided 1" }, 0),
]
.into_iter()
.map(transaction)
.collect::<alloc::vec::Vec<_>>();
let unsigned = {
let mut unsigned = [(TransactionKind::Unsigned, 0), (TransactionKind::Unsigned, 1)]
.into_iter()
.map(transaction)
.collect::<alloc::vec::Vec<_>>();
unsigned.sort_by_key(Transaction::hash);
unsigned
};
let signed = [
(TransactionKind::Signed {
scope: alloc::vec![1].into_boxed_slice(),
signed: Signed { signer: [0xaa; 32], nonce: 0, signature: [0; 64] },
}),
(TransactionKind::Signed {
scope: alloc::vec![1].into_boxed_slice(),
signed: Signed { signer: [0xaa; 32], nonce: 1, signature: [0; 64] },
}),
(TransactionKind::Signed {
scope: alloc::vec![1].into_boxed_slice(),
signed: Signed { signer: [0xaa; 32], nonce: 2, signature: [0; 64] },
}),
(TransactionKind::Signed {
scope: alloc::vec![2].into_boxed_slice(),
signed: Signed { signer: [0xaa; 32], nonce: 0, signature: [0; 64] },
}),
(TransactionKind::Signed {
scope: alloc::vec![3].into_boxed_slice(),
signed: Signed { signer: [0xaa; 32], nonce: 5, signature: [0; 64] },
}),
(TransactionKind::Signed {
scope: alloc::vec![0].into_boxed_slice(),
signed: Signed { signer: [0xbb; 32], nonce: 0, signature: [0; 64] },
}),
]
.into_iter()
.map(|kind| transaction((kind, 0)))
.collect::<alloc::vec::Vec<_>>();
{
let transactions = provided.iter().chain(unsigned.iter()).chain(signed.iter());
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions).expect("sorted");
}
{
let transactions = unsigned.iter().chain(provided.iter());
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("unsigned before provided");
}
{
let transactions = signed.iter().chain(provided.iter());
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("signed before provided");
}
{
let transactions = signed.iter().chain(unsigned.iter());
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("signed before unsigned");
}
{
let transactions = provided.iter().rev();
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("provided with reversed scopes");
}
{
let transactions = unsigned.iter().rev();
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("unsigned with reversed hashes");
}
{
let transactions = unsigned.first().into_iter().chain(unsigned.iter());
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("unsigned with repeated transactions");
}
{
fn increment(digits: &mut [usize], limit: usize) -> bool {
let mut carry = true;
for digit in digits {
*digit += usize::from(u8::from(carry));
carry = *digit == limit;
if carry {
*digit = 0;
}
}
!carry
}
let mut order = alloc::vec![0; signed.len()];
while increment(&mut order, signed.len()) {
if order != (0 .. signed.len()).collect::<alloc::vec::Vec<_>>() {
let transactions = order.iter().map(|i| &signed[*i]);
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("non-sorted signed transactions");
}
}
}
{
let transactions =
signed.iter().filter(|transaction| {
if let TransactionKind::Signed {
scope: _,
signed: Signed { signer: _, nonce, signature: _ },
} = transaction.kind() &&
(nonce == 1)
{
return false;
}
true
});
Block::<TestTransaction>::verify_syntax_transactions(genesis, transactions)
.expect_err("gap between nonces 0 and 2");
}
{
let transactions =
provided.iter().chain(unsigned.iter()).chain(signed.iter()).cloned().collect::<Box<_>>();
for i in 0 .. transactions.len() {
let mut transactions = transactions.clone();
transactions[i].valid = false;
Block::<TestTransaction>::verify_syntax_transactions(genesis, &transactions)
.expect_err("invalid transaction");
}
}
{
let transactions = signed.iter().cloned().collect::<Box<_>>();
for i in 0 .. transactions.len() {
let mut transactions = transactions.clone();
{
let TransactionKind::Signed { scope: _, signed: Signed { signer, .. } } =
&mut transactions[i].kind
else {
panic!("non-signed transaction in `signed`")
};
signer[0] ^= 1;
}
Block::<TestTransaction>::verify_syntax_transactions(genesis, &transactions)
.expect_err("malleated signer");
}
}
{
let transactions = signed.iter().cloned().collect::<Box<_>>();
for i in 0 .. transactions.len() {
let mut transactions = transactions.clone();
{
let TransactionKind::Signed { scope: _, signed: Signed { signature, .. } } =
&mut transactions[i].kind
else {
panic!("non-signed transaction in `signed`")
};
signature[0] ^= 1;
}
Block::<TestTransaction>::verify_syntax_transactions(genesis, &transactions)
.expect_err("malleated signature");
}
}
}