Struct grin_core::core::transaction::Transaction

pub struct Transaction {
    pub offset: BlindingFactor,
    pub body: TransactionBody,
}

A transaction

Fields

offset: BlindingFactor

The kernel "offset" k2 excess is k1G after splitting the key k = k1 + k2

body: TransactionBody

The transaction body - inputs/outputs/kernels

Methods

impl Transaction

pub fn empty() -> Transaction

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

pub fn new(
    inputs: Vec<Input>,
    outputs: Vec<Output>,
    kernels: Vec<TxKernel>
) -> Transaction

Creates a new transaction initialized with the provided inputs, outputs, kernels

pub fn with_offset(self, offset: BlindingFactor) -> Transaction

Creates a new transaction using this transaction as a template and with the specified offset.

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

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

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

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

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

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

pub fn inputs(&self) -> &Vec<Input>

Get inputs

pub fn inputs_mut(&mut self) -> &mut Vec<Input>

Get inputs mutable

pub fn outputs(&self) -> &Vec<Output>

Get outputs

pub fn outputs_mut(&mut self) -> &mut Vec<Output>

Get outputs mutable

pub fn kernels(&self) -> &Vec<TxKernel>

Get kernels

pub fn kernels_mut(&mut self) -> &mut Vec<TxKernel>

Get kernels mut

pub fn fee(&self) -> u64

Total fee for a transaction is the sum of fees of all kernels.

pub fn overage(&self) -> i64

Total overage across all kernels.

pub fn lock_height(&self) -> u64

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

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

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

• rangeproof verification (on the body)
• kernel signature verification (on the body)
• kernel sum verification

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

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

pub fn fee_to_weight(&self) -> u64

Can be used to compare txs by their fee/weight ratio. Don't use these values for anything else though due to precision multiplier.

pub fn tx_weight(&self) -> usize

Calculate transaction weight

pub fn tx_weight_as_block(&self) -> usize

Calculate transaction weight as a block

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

Calculate transaction weight from transaction details

Trait Implementations

impl Committed for Transaction

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 DefaultHashable for Transaction

impl Writeable for Transaction

Implementation of Writeable for a fully blinded transaction, defines how to write the transaction 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 Transaction

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

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

Reads the data necessary to this Readable from the provided reader

impl PartialEq<Transaction> for Transaction

PartialEq

fn eq(&self, tx: &Transaction) -> 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 Transaction

fn default() -> Transaction

Returns the "default value" for a type.

impl Into<TransactionBody> for Transaction

fn into(self) -> TransactionBody

Performs the conversion.

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Serialize for Transaction

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 Transaction

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

Deserialize this value from the given Serde deserializer.