Struct tuxedo_core::types::Transaction

pub struct Transaction<V, C> {
    pub inputs: Vec<Input>,
    pub peeks: Vec<OutputRef>,
    pub outputs: Vec<Output<V>>,
    pub checker: C,
}

A UTXO Transaction

Each transaction consumes some UTXOs (the inputs) and creates some new ones (the outputs).

The Transaction type is generic over two orthogonal pieces of validation logic:

1. Verifier - A verifier checks that an individual input may be consumed. A typical example of a verifier is checking that there is a signature by the proper owner. Other examples may be that anyone can consume the input or no one can, or that a proof of work is required.
2. ConstraintCheckers - A constraint checker checks that the transaction as a whole meets a set of requirements. For example, that the total output value of a cryptocurrency transaction does not exceed its input value. Or that a cryptokitty was created with the correct genetic material from its parents.

In the future, there may be additional notions of peeks (inputs that are not consumed) and evictions (inputs that are forcefully consumed.) Existing state to be read and consumed from storage

Fields

inputs: Vec<Input>

Existing pieces of state to be read and consumed from storage

peeks: Vec<OutputRef>

Existing state to be read, but not consumed, from storage

outputs: Vec<Output<V>>

New state to be placed into storage

checker: C

Which piece of constraint checking logic is used to determine whether this transaction is valid

Implementations

impl<V: Clone, C: Clone> Transaction<V, C>

pub fn transform<D: From<C>>(&self) -> Transaction<V, D>

A helper function for transforming a transaction generic over one kind of constraint checker into a transaction generic over another type of constraint checker. This is useful when moving up and down the aggregation tree.

Trait Implementations

impl<V: Clone, C: Clone> Clone for Transaction<V, C>

fn clone(&self) -> Transaction<V, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, C: Debug> Debug for Transaction<V, C>

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

Formats the value using the given formatter.

impl<V: Decode, C: Decode> Decode for Transaction<V, C>

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<V: Default, C: Default> Default for Transaction<V, C>

fn default() -> Transaction<V, C>

Returns the “default value” for a type.

impl<'de, V, C> Deserialize<'de> for Transaction<V, C>

where V: Deserialize<'de>, C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: Encode, C: Encode> Encode for Transaction<V, C>

fn encode_to<T: Output + ?Sized>(&self, dest: &mut T)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<V, C> Extrinsic for Transaction<V, C>

where C: TypeInfo + ConstraintChecker + 'static, V: TypeInfo + Verifier + 'static,

type Call = Transaction<V, C>

The function call.

type SignaturePayload = ()

The payload we carry for signed extrinsics.

fn new(data: Self, _: Option<Self::SignaturePayload>) -> Option<Self>

Create new instance of the extrinsic.

fn is_signed(&self) -> Option<bool>

Is this Extrinsic signed? If no information are available about signed/unsigned, None should be returned.

impl<V: PartialEq, C: PartialEq> PartialEq for Transaction<V, C>

fn eq(&self, other: &Transaction<V, C>) -> 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<V, C> Serialize for Transaction<V, C>

where V: Serialize, C: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V, C> TypeInfo for Transaction<V, C>

where Vec<Output<V>>: TypeInfo + 'static, C: TypeInfo + 'static, V: TypeInfo + 'static,

type Identity = Transaction<V, C>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<V: Eq, C: Eq> Eq for Transaction<V, C>

impl<V, C> StructuralPartialEq for Transaction<V, C>