Struct themelio_structs::Transaction

pub struct Transaction {
    pub kind: TxKind,
    pub inputs: Vec<CoinID>,
    pub outputs: Vec<CoinData>,
    pub fee: CoinValue,
    pub covenants: Vec<Bytes>,
    pub data: Bytes,
    pub sigs: Vec<Bytes>,
}

Transaction represents an individual, serializable Themelio transaction.

Fields

kind: TxKind

The “kind” of the transaction. Most transactions are of kind TxKind::Normal.

inputs: Vec<CoinID>

The coins that this transaction spends, identified by CoinID (transaction hash and index)

outputs: Vec<CoinData>

The outputs that this transaction creates.

fee: CoinValue

The fee paid by this transaction, in MEL.

covenants: Vec<Bytes>

The contents of the covenants locking the coins spent by this transaction. Themelio is uniformly “pay to script hash”, so coins (CoinDatas) themselves only contain the hash of the covenant locking the coin. The spending transaction must provide the actual covenants (in MelVM bytecode).

The ordering of this field does not matter. As long as there is some element in covenants corresponding to each unique covhash of the coins being spent, we’re good.

data: Bytes

Arbitrary additional data of the transaction. Used mostly for unlocking covenants, as well as playing a special role in Melswap and Melmint transactions.

sigs: Vec<Bytes>

A place to place cryptographically malleable data, usually signatures. The reason why we use this rather than data is because sigs is ignored when computing the unique hash of a transaction (see Transaction::hash_nosigs), which is important for checking whether a particular transaction went through while scanning the blockchain by transaction hash. (This is similar to the reason SegWit was included in Bitcoin)

Implementations

impl Transaction

pub fn new(kind: TxKind) -> Self

Creates a new transaction with the given kind, no inputs, no outputs, no nothing.

pub fn is_well_formed(&self) -> bool

Checks whether or not the transaction is well formed, respecting coin size bounds and such. Does not fully validate the transaction.

pub fn hash_nosigs(&self) -> TxHash

hash_nosigs returns the hash of the transaction with a zeroed-out signature field. This is what signatures are computed against.

pub fn signed_ed25519(self, sk: Ed25519SK) -> Self

sign_ed25519 consumes the transaction, appends an ed25519 signature, and returns it.

pub fn total_outputs(&self) -> HashMap<Denom, CoinValue>

total_outputs returns a HashMap mapping each type of coin to its total value. Fees will be included in the Mel cointype.

pub fn covenants_as_map(&self) -> HashMap<Address, Bytes>

scripts_as_map returns a HashMap mapping the hash of each script in the transaction to the script itself.

pub fn base_fee(
    &self,
    fee_multiplier: u128,
    ballast: u128,
    cov_to_weight: impl Fn(&[u8]) -> u128
) -> CoinValue

Returns the minimum fee of the transaction at a given fee multiplier, with a given “ballast”.

pub fn weight(&self, cov_to_weight: impl Fn(&[u8]) -> u128) -> u128

Returns the weight of the transaction, given a function that maps a covenant to its weight.

pub fn output_coinid(&self, index: u8) -> CoinID

Convenience function that constructs a CoinID that points to a certain output of this transaction. Panics if the index is out of bounds.

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Transaction> for Transaction

fn eq(&self, other: &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 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 Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction