Struct ergo_lib::chain::transaction::Transaction

pub struct Transaction {
    pub inputs: Vec<Input>,
    pub data_inputs: Vec<DataInput>,
    pub output_candidates: Vec<ErgoBoxCandidate>,
    // some fields omitted
}

ErgoTransaction is an atomic state transition operation. It destroys Boxes from the state and creates new ones. If transaction is spending boxes protected by some non-trivial scripts, its inputs should also contain proof of spending correctness - context extension (user-defined key-value map) and data inputs (links to existing boxes in the state) that may be used during script reduction to crypto, signatures that satisfies the remaining cryptographic protection of the script. Transactions are not encrypted, so it is possible to browse and view every transaction ever collected into a block.

Fields

inputs: Vec<Input>

inputs, that will be spent by this transaction.

data_inputs: Vec<DataInput>

inputs, that are not going to be spent by transaction, but will be reachable from inputs scripts. dataInputs scripts will not be executed, thus their scripts costs are not included in transaction cost and they do not contain spending proofs.

output_candidates: Vec<ErgoBoxCandidate>

box candidates to be created by this transaction. Differ from ordinary ones in that they do not include transaction id and index

Implementations

impl Transaction

pub const MAX_OUTPUTS_COUNT: usize

Maximum number of outputs

pub fn new(
    inputs: Vec<Input>,
    data_inputs: Vec<DataInput>,
    output_candidates: Vec<ErgoBoxCandidate>
) -> Transaction

Creates new transaction

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

create ErgoBox from ErgoBoxCandidate with tx id and indices

pub fn bytes_to_sign(&self) -> Vec<u8>

Serialized tx with empty proofs

pub fn id(&self) -> TxId

Get transaction id

Trait Implementations

impl Clone for Transaction

pub fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transaction

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Transaction> for Transaction

pub fn eq(&self, other: &Transaction) -> bool

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

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

This method tests for !=.

impl Serialize for Transaction

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

Serialize this value into the given Serde serializer.

impl SigmaSerializable for Transaction

pub fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> Result<(), Error>

Write self to the given writer. This function has a sigma_ prefix to alert the reader that the serialization in use is consensus-critical serialization
Notice that the error type is std::io::Error; this indicates that serialization MUST be infallible up to errors in the underlying writer. In other words, any type implementing SigmaSerializable must make illegal states unrepresentable.

pub fn sigma_parse<R: SigmaByteRead>(
    r: &mut R
) -> Result<Self, SerializationError>

Try to read self from the given reader. sigma- prefix to alert the reader that the serialization in use is consensus-critical

pub fn sigma_serialize_bytes(&self) -> Vec<u8>

Serialize any SigmaSerializable value into bytes

pub fn sigma_parse_bytes(mut bytes: Vec<u8>) -> Result<Self, SerializationError>

Parse self from the bytes

impl StructuralPartialEq for Transaction