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 const MAX_TOKENS_COUNT: usize

Maximum number of tokens in the box

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

pub fn get_register(&self, id: RegisterId) -> Option<Constant>

Get register value

Trait Implementations

impl Clone for ErgoBox

pub fn clone(&self) -> ErgoBox

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErgoBox

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

Formats the value using the given formatter.

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

pub 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

pub fn value(&self) -> BoxValue

Box value

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

Tokens (ids and amounts)

impl ErgoBoxId for ErgoBox

pub fn box_id(&self) -> BoxId

Id of the ergo box

impl From<ErgoBox> for Constant

pub fn from(b: ErgoBox) -> Self

Performs the conversion.

impl From<ErgoBox> for Value

pub fn from(b: ErgoBox) -> Self

Performs the conversion.

impl From<ErgoBox> for ErgoBoxCandidate

pub fn from(b: ErgoBox) -> Self

Performs the conversion.

impl LiftIntoSType for ErgoBox

pub fn stype() -> SType

get SType

impl PartialEq<ErgoBox> for ErgoBox

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

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

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

This method tests for !=.

impl Serialize for ErgoBox

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 ErgoBox

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 StoredNonPrimitive for ErgoBox

impl StructuralEq for ErgoBox

impl StructuralPartialEq for ErgoBox

impl TryExtractFrom<Value> for ErgoBox

pub fn try_extract_from(c: Value) -> Result<Self, TryExtractFromError>

Extract the value or return an error if type does not match