Struct ergo_lib::chain::ergo_box::ErgoBox

pub struct ErgoBox {
    pub value: BoxValue,
    pub ergo_tree: ErgoTree,
    pub tokens: Vec<Token>,
    pub additional_registers: NonMandatoryRegisters,
    pub creation_height: u32,
    pub transaction_id: TxId,
    pub index: u16,
    // some fields omitted
}

Box (aka coin, or an unspent output) is a basic concept of a UTXO-based cryptocurrency. In Bitcoin, such an object is associated with some monetary value (arbitrary, but with predefined precision, so we use integer arithmetic to work with the value), and also a guarding script (aka proposition) to protect the box from unauthorized opening.

In other way, a box is a state element locked by some proposition (ErgoTree).

In Ergo, box is just a collection of registers, some with mandatory types and semantics, others could be used by applications in any way. We add additional fields in addition to amount and proposition~(which stored in the registers R0 and R1). Namely, register R2 contains additional tokens (a sequence of pairs (token identifier, value)). Register R3 contains height specified by user (protocol checks if it was <= current height when transaction was accepted) and also transaction identifier and box index in the transaction outputs. Registers R4-R9 are free for arbitrary usage.

A transaction is unsealing a box. As a box can not be open twice, any further valid transaction can not be linked to the same box.

Fields

value: BoxValue

amount of money associated with the box

ergo_tree: ErgoTree

guarding script, which should be evaluated to true in order to open this box

tokens: Vec<Token>

secondary tokens the box contains

additional_registers: NonMandatoryRegisters

additional registers the box can carry over

creation_height: u32

height when a transaction containing the box was created. This height is declared by user and should not exceed height of the block, containing the transaction with this box.

transaction_id: TxId

id of transaction which created the box

index: u16

number of box (from 0 to total number of boxes the transaction with transactionId created - 1)

Implementations

impl ErgoBox

pub fn new(
    value: BoxValue,
    ergo_tree: ErgoTree,
    tokens: Vec<Token>,
    additional_registers: NonMandatoryRegisters,
    creation_height: u32,
    transaction_id: TxId,
    index: u16
) -> ErgoBox

Crate new box

pub fn box_id(&self) -> BoxId

Box id (Blake2b256 hash of serialized box)

pub fn from_box_candidate(
    box_candidate: &ErgoBoxCandidate,
    transaction_id: TxId,
    index: u16
) -> ErgoBox

Create ErgoBox from ErgoBoxCandidate by adding transaction id and index of the box in the transaction

Trait Implementations

impl Clone for ErgoBox

fn clone(&self) -> ErgoBox

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErgoBox

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErgoBox

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

Deserialize this value from the given Serde deserializer.

impl Eq for ErgoBox

impl ErgoBoxAssets for ErgoBox

fn value(&self) -> BoxValue

Box value

fn tokens(&self) -> Vec<Token>

Tokens (ids and amounts)

impl ErgoBoxId for ErgoBox

fn box_id(&self) -> BoxId

Id of the ergo box

impl From<ErgoBox> for ErgoBoxCandidate

fn from(b: ErgoBox) -> Self

Performs the conversion.

impl PartialEq<ErgoBox> for ErgoBox

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

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

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

This method tests for !=.

impl Serialize for ErgoBox

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 ErgoBox

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.

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

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

Serialize any SigmaSerializable value into bytes

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

Parse self from the bytes

impl StructuralEq for ErgoBox

impl StructuralPartialEq for ErgoBox