Struct MutableTransaction 

pub struct MutableTransaction<T: AsRef<Transaction> = Arc<Transaction>> {
    pub tx: T,
    pub entries: Vec<Option<UtxoEntry>>,
    pub calculated_fee: Option<u64>,
    pub calculated_compute_mass: Option<u64>,
}

Represents a generic mutable/readonly/pointer transaction type along with partially filled UTXO entry data and optional fee and mass

Fields

tx: T

The inner transaction

entries: Vec<Option<UtxoEntry>>

Partially filled UTXO entry data

calculated_fee: Option<u64>

Populated fee

calculated_compute_mass: Option<u64>

Populated compute mass (does not include the storage mass)

Implementations

impl<T: AsRef<Transaction>> MutableTransaction<T>

pub fn new(tx: T) -> Self

pub fn id(&self) -> TransactionId

pub fn with_entries(tx: T, entries: Vec<UtxoEntry>) -> Self

pub fn as_verifiable(&self) -> impl VerifiableTransaction + '_

Returns the tx wrapped as a VerifiableTransaction. Note that this function must be called only once all UTXO entries are populated, otherwise it panics.

pub fn is_verifiable(&self) -> bool

pub fn is_fully_populated(&self) -> bool

pub fn missing_outpoints( &self, ) -> impl Iterator<Item = TransactionOutpoint> + '_

pub fn clear_entries(&mut self)

pub fn calculated_feerate(&self) -> Option<f64>

Returns the calculated feerate. The feerate is calculated as the amount of fee this transactions pays per gram of the full contextual (compute & storage) mass. The function returns a value when calculated fee exists and the contextual mass is greater than zero, otherwise None is returned.

pub fn mempool_estimated_bytes(&self) -> usize

A function for estimating the amount of memory bytes used by this transaction (dedicated to mempool usage). We need consistency between estimation calls so only this function should be used for this purpose since estimate_mem_bytes is sensitive to pointer wrappers such as Arc

pub fn has_parent(&self, possible_parent: TransactionId) -> bool

pub fn has_parent_in_set( &self, possible_parents: &HashSet<TransactionId>, ) -> bool

impl MutableTransaction

Specialized impl for T=Arc<Transaction>

pub fn from_tx(tx: Transaction) -> Self

Trait Implementations

impl<T: AsRef<Transaction>> AsRef<Transaction> for MutableTransaction<T>

fn as_ref(&self) -> &Transaction

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + AsRef<Transaction>> Clone for MutableTransaction<T>

fn clone(&self) -> MutableTransaction<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AsRef<Transaction>> Debug for MutableTransaction<T>

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

Formats the value using the given formatter.

impl<T: AsRef<Transaction>> MemSizeEstimator for MutableTransaction<T>

fn estimate_mem_bytes(&self) -> usize

Estimates the (deep) size of this object in bytes (including heap owned inner data)

fn estimate_size(&self, mem_mode: MemMode) -> usize

Estimates the size of this object depending on the passed mem mode

fn estimate_mem_units(&self) -> usize

Estimates the number of units this object holds in memory where the unit byte size is usually a constant known to the caller as well (and hence we avoid computing it over and over)

impl<T: PartialEq + AsRef<Transaction>> PartialEq for MutableTransaction<T>

fn eq(&self, other: &MutableTransaction<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq + AsRef<Transaction>> Eq for MutableTransaction<T>

impl<T: AsRef<Transaction>> StructuralPartialEq for MutableTransaction<T>