pub struct Block<T: Transaction> { /* private fields */ }Expand description
A block.
A block is defined as its header, a list of slashes, amd a list of transactions, as committed to within the block’s header.
The slashes MUST be sorted by the slashed validator.
The transactions MUST be ordered as provided, unsigned, signed, with:
- The provided transactions sorted by their scopes
- The unsigned transactions sorted by their hashes
- The signed transactions sorted by their signers, then their scopes, then their nonces
These strict requirements on ordering allow single-pass verification, without any dynamic allocations, that a block is free of conflicting unsigned/signed transactions (a problem which is considered an instance of an invalid ordering). It also allows checking provided transactions one scope at a time, and straight-line application of a block’s signed transactions, after having prioritized the provided and unsigned transactions which imply some level of recognition within the application.
The Tributary DOES NOT enforce the uniqueness of signed transactions’ hashes, where signed transactions’ hashes MUST bind to all of their semantic contents.
The block’s serialization prefixes the list of slashes with the two-byte little-endian encoding
of its length and the list of transactions with the four-byte little-endian encoding of its
length. The limit on slashes is complete as there are at most u16::MAX validators. The
limit on transactions is practical and enforced as a syntactic requirement.
Implementations§
Source§impl<T: Transaction> Block<T>
impl<T: Transaction> Block<T>
Sourcepub fn verify_syntax(&self, genesis: [u8; 32]) -> Result<(), SyntacticError>
pub fn verify_syntax(&self, genesis: [u8; 32]) -> Result<(), SyntacticError>
Verify this block’s syntax.
This is a check which can be performed without any context or state, other than the genesis hash, allowing it to be performed in response to network traffic before acquiring any mutexes or occupying any channels.
This DOES verify the slashed validators are committed to within the block’s header. This
DOES NOT verify the slashes themselves, which is semantic. This enables malleability in that
a malicious peer MAY substitute a valid slash reason for a validator with an invalid slash
reason for the same validator. The reason for a slash may be verified via Slash::verify,
solely requiring the context which spawned the Tributary (not its current state).
This DOES verify the transactions are committed to within the block’s header. This DOES verify the signed transaction’s signatures. If the application’s transaction type omits signatures from the transaction’s hash, due to them not affecting the semantic meaning of the transaction, a malicious peer MAY substitute a signed transaction’s valid signature with an invalid signature.
If the block is agreed upon by the validators via the consensus process, there MUST be valid uncommitted data available so long as the honest-majority assumption is upheld. This means if a block is received with invalid data which wasn’t committed to, but the block is agreed upon, it is the peer which should be considered valid, not the block. The uncommitted data should be retrieved from an honest peer instead.
For blocks without agreement under consensus, it would not appear immediate to determine if a block with invalid uncommitted data is due to a malicious proposer or a malicious peer. However, if the block was received from a peer who isn’t the proposer, the peer MUST be faulty, as the peer either malleated the block to be invalid themselves or chose to relay an invalid block (assuming the gossip layer does not simply relay every message seen without any scrutiny).
Sourcepub fn instantiate(
genesis: [u8; 32],
parent: [u8; 32],
time: u64,
slashes: Box<[Slash]>,
transactions: Box<[T]>,
) -> Result<Self, SyntacticError>
pub fn instantiate( genesis: [u8; 32], parent: [u8; 32], time: u64, slashes: Box<[Slash]>, transactions: Box<[T]>, ) -> Result<Self, SyntacticError>
Instantiate a block.
This will check the block is syntactically valid via Block::verify_syntax. It is intended
to enable optimized peer-to-peer layers, where the application syncs block headers
independently from their contents, where fine control over each individual item is required
(e.g. if a single item was malleated and should be replaced).
Sourcepub fn time(&self) -> u64
pub fn time(&self) -> u64
This block’s time.
See BlockHeader::time for more information.
Sourcepub fn hash(&self) -> [u8; 32]
pub fn hash(&self) -> [u8; 32]
The hash of this block.
This is defined as the hash of its header.
Sourcepub fn transactions(&self) -> &[T]
pub fn transactions(&self) -> &[T]
The transactions within this block.
Trait Implementations§
Source§impl<T: Transaction> ReadWrite for Block<T>
impl<T: Transaction> ReadWrite for Block<T>
Source§fn read(reader: impl Read) -> Result<Self>
fn read(reader: impl Read) -> Result<Self>
This will read a block with no size limits applied. While this will not reserve capacity for the alleged length of lists, meaning the amount of memory consumed is proportional to the amount of bytes read, the caller is expected to ensure they are prepared to read this block in its entirety.
Applications SHOULD apply their own size limit to the reader itself to prevent a potential Denial of Service by transmitting several GB of data which, if deserialized, will then be stored in memory.
Auto Trait Implementations§
impl<T> Freeze for Block<T>
impl<T> RefUnwindSafe for Block<T>
impl<T> Send for Block<T>
impl<T> Sync for Block<T>
impl<T> Unpin for Block<T>
impl<T> UnsafeUnpin for Block<T>
impl<T> UnwindSafe for Block<T>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.