Struct Transaction

pub struct Transaction {
    pub inputs: TxIoVec<Input>,
    pub data_inputs: Option<TxIoVec<DataInput>>,
    pub output_candidates: TxIoVec<ErgoBoxCandidate>,
    pub outputs: TxIoVec<ErgoBox>,
    /* private fields */
}

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: TxIoVec<Input>

inputs, that will be spent by this transaction.

data_inputs: Option<TxIoVec<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: TxIoVec<ErgoBoxCandidate>

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

outputs: TxIoVec<ErgoBox>

Boxes to be created by this transaction. Differ from Self::output_candidates in that they include transaction id and index

Implementations

impl Transaction

pub const MAX_OUTPUTS_COUNT: usize = 65_535usize

Maximum number of outputs

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

Creates new transaction from vectors

pub fn new( inputs: TxIoVec<Input>, data_inputs: Option<TxIoVec<DataInput>>, output_candidates: TxIoVec<ErgoBoxCandidate>, ) -> Result<Transaction, SigmaSerializationError>

Creates new transaction

pub fn from_unsigned_tx( unsigned_tx: UnsignedTransaction, proofs: Vec<ProofBytes>, ) -> Result<Self, TransactionError>

Create Transaction from UnsignedTransaction and an array of proofs in the same order as UnsignedTransaction.inputs

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

Serialized tx with empty proofs

pub fn id(&self) -> TxId

Get transaction id

pub fn verify_p2pk_input( &self, input_box: ErgoBox, ) -> Result<bool, TransactionSignatureVerificationError>

Check the signature of the transaction’s input corresponding to the given input box, guarded by P2PK script

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate 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<'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 ErgoTransaction for Transaction

fn inputs_ids(&self) -> impl ExactSizeIterator<Item = BoxId>

input boxes ids

fn data_inputs(&self) -> Option<&[DataInput]>

data input boxes

fn outputs(&self) -> &[ErgoBox]

output boxes

fn context_extension(&self, input_index: usize) -> Option<ContextExtension>

ContextExtension for the given input index

fn validate_stateless(&self) -> Result<(), TxValidationError>

Stateless transaction validation (no blockchain context) for a transaction Returns [Ok(())] if validation has succeeded or returns TxValidationError

impl PartialEq for Transaction

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

fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> SigmaSerializeResult

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

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

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

fn sigma_serialize_bytes(&self) -> Result<Vec<u8>, SigmaSerializationError>

Serialize any SigmaSerializable value into bytes

fn sigma_parse_bytes(bytes: &[u8]) -> Result<Self, SigmaParsingError>

Parse self from the bytes

impl Eq for Transaction

impl StructuralPartialEq for Transaction