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

Implementations

impl Transaction

pub fn empty() -> Transaction

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

pub fn new( inputs: Inputs, outputs: &[Output], kernels: &[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 kernel added. Existing kernels, if any, are kept intact. Sort order is maintained.

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

Builds a new transaction replacing any existing kernels with the provided kernel.

pub fn inputs(&self) -> Inputs

Get inputs

pub fn outputs(&self) -> &[Output]

Get outputs

pub fn kernels(&self) -> &[TxKernel]

Get kernels

pub fn fee(&self) -> u64

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

pub fn shifted_fee(&self) -> u64

Shifted fee for a transaction is the sum of fees of all kernels shifted right by the maximum fee shift

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

aggregate fee_fields from all appropriate kernels in transaction into one

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) -> 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_rate(&self) -> u64

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

pub fn weight(&self) -> u64

Calculate transaction weight

pub fn accept_fee(&self) -> u64

Transaction minimum acceptable fee

pub fn old_weight_by_iok( num_inputs: u64, num_outputs: u64, num_kernels: u64 ) -> u64

Old weight definition for pool acceptance

pub fn weight_by_iok(num_inputs: u64, num_outputs: u64, num_kernels: u64) -> u64

Calculate transaction weight from transaction details

Trait Implementations

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

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

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

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.

impl From<Transaction> for TransactionBody

fn from(tx: Transaction) -> Self

Converts to this type from the input type.

impl PartialEq for Transaction

PartialEq

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

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

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

Reads the data necessary to this Readable from the provided reader

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