Enum tributary_chain::transaction::TransactionKind

pub enum TransactionKind<'a> {
    Provided(&'static str),
    Unsigned,
    Signed(Vec<u8>, &'a Signed),
}

Variants

Provided(&'static str)

This transaction should be provided by every validator, in an exact order.

The contained static string names the orderer to use. This allows two distinct provided transaction kinds, without a synchronized order, to be ordered within their own kind without requiring ordering with each other.

The only malleability is in when this transaction appears on chain. The block producer will include it when they have it. Block verification will fail for validators without it.

If a supermajority of validators produce a commit for a block with a provided transaction which isn’t locally held, the block will be added to the local chain. When the transaction is locally provided, it will be compared for correctness to the on-chain version

In order to ensure TXs aren’t accidentally provided multiple times, all provided transactions must have a unique hash which is also unique to all Unsigned transactions.

Unsigned

An unsigned transaction, only able to be included by the block producer.

Once an Unsigned transaction is included on-chain, it may not be included again. In order to have multiple Unsigned transactions with the same values included on-chain, some distinct nonce must be included in order to cause a distinct hash.

The hash must also be unique with all Provided transactions.

Signed(Vec<u8>, &'a Signed)

A signed transaction.

Trait Implementations

impl<'a> Clone for TransactionKind<'a>

fn clone(&self) -> TransactionKind<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for TransactionKind<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for TransactionKind<'a>

fn eq(&self, other: &TransactionKind<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for TransactionKind<'a>

impl<'a> StructuralPartialEq for TransactionKind<'a>