Struct grin_core::core::transaction::TransactionBody

pub struct TransactionBody {
    pub inputs: Vec<Input>,
    pub outputs: Vec<Output>,
    pub kernels: Vec<TxKernel>,
}

TransactionBody is a common abstraction for transaction and block

Fields

inputs: Vec<Input>

List of inputs spent by the transaction.

outputs: Vec<Output>

List of outputs the transaction produces.

kernels: Vec<TxKernel>

List of kernels that make up this transaction (usually a single kernel).

Methods

impl TransactionBody

pub fn empty() -> TransactionBody

Creates a new empty transaction (no inputs or outputs, zero fee).

pub fn sort(&mut self)

Sort the inputs|outputs|kernels.

pub fn init(
    inputs: Vec<Input>,
    outputs: Vec<Output>,
    kernels: Vec<TxKernel>,
    verify_sorted: bool
) -> Result<TransactionBody, Error>

Creates a new transaction body initialized with the provided inputs, outputs and kernels. Guarantees inputs, outputs, kernels are sorted lexicographically.

pub fn with_input(self, input: Input) -> TransactionBody

Builds a new body with the provided inputs added. Existing inputs, if any, are kept intact. Sort order is maintained.

pub fn with_output(self, output: Output) -> TransactionBody

Builds a new TransactionBody with the provided output added. Existing outputs, if any, are kept intact. Sort order is maintained.

pub fn with_kernel(self, kernel: TxKernel) -> TransactionBody

Builds a new TransactionBody with the provided kernel added. Existing kernels, if any, are kept intact. Sort order is maintained.

pub fn body_weight(&self) -> usize

Calculate transaction weight

pub fn body_weight_as_block(&self) -> usize

Calculate weight of transaction using block weighing

pub fn weight(input_len: usize, output_len: usize, kernel_len: usize) -> usize

Calculate transaction weight from transaction details. This is non consensus critical and compared to block weight, incentivizes spending more outputs (to lower the fee).

pub fn weight_as_block(
    input_len: usize,
    output_len: usize,
    kernel_len: usize
) -> usize

Calculate transaction weight using block weighing from transaction details. Consensus critical and uses consensus weight values.

pub fn lock_height(&self) -> u64

Lock height of a body is the max lock height of the kernels.

pub fn verify_features(&self) -> Result<(), Error>

Verify we have no invalid outputs or kernels in the transaction due to invalid features. Specifically, a transaction cannot contain a coinbase output or a coinbase kernel.

pub fn validate_read(&self, weighting: Weighting) -> Result<(), Error>

"Lightweight" validation that we can perform quickly during read/deserialization. Subset of full validation that skips expensive verification steps, specifically -

• rangeproof verification
• kernel signature verification

pub fn validate(
    &self,
    weighting: Weighting,
    verifier: Arc<RwLock<dyn VerifierCache>>
) -> Result<(), Error>

Validates all relevant parts of a transaction body. Checks the excess value against the signature as well as range proofs for each output.

Trait Implementations

impl Committed for TransactionBody

fn inputs_committed(&self) -> Vec<Commitment>

Vector of input commitments to verify.

fn outputs_committed(&self) -> Vec<Commitment>

Vector of output commitments to verify.

fn kernels_committed(&self) -> Vec<Commitment>

Vector of kernel excesses to verify.

fn sum_kernel_excesses(
    &self,
    offset: &BlindingFactor
) -> Result<(Commitment, Commitment), Error>

Gather the kernel excesses and sum them.

fn sum_commitments(&self, overage: i64) -> Result<Commitment, Error>

Gathers commitments and sum them.

fn verify_kernel_sums(
    &self,
    overage: i64,
    kernel_offset: BlindingFactor
) -> Result<(Commitment, Commitment), Error>

Verify the sum of the kernel excesses equals the sum of the outputs, taking into account both the kernel_offset and overage.

impl Writeable for TransactionBody

Implementation of Writeable for a body, defines how to write the body as binary.

fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>

Write the data held by this Writeable to the provided writer

impl Readable for TransactionBody

Implementation of Readable for a body, defines how to read a body from a binary stream.

fn read(reader: &mut dyn Reader) -> Result<TransactionBody, Error>

Reads the data necessary to this Readable from the provided reader

impl PartialEq<TransactionBody> for TransactionBody

PartialEq

fn eq(&self, l: &TransactionBody) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Default for TransactionBody

fn default() -> TransactionBody

Returns the "default value" for a type.

impl Into<TransactionBody> for Transaction

fn into(self) -> TransactionBody

Performs the conversion.

impl Clone for TransactionBody

fn clone(&self) -> TransactionBody

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionBody

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

Formats the value using the given formatter.

impl Serialize for TransactionBody

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for TransactionBody

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.