Struct Issue

pub struct Issue {
    pub version: ReservedBytes<1>,
    pub meta: ContractMeta,
    pub codex: Codex,
    pub genesis: Genesis,
}

Information on the issue of the contract.

Fields

version: ReservedBytes<1>

Version of the contract issue data structure.

This version defines an overall contract version. Operations and Genesis have independent versioning. Correspondence between these versions will be defined by the future consensus rules.

Future use

For now, the only supported version is one; thus, a ReservedBytes is used.

In the future, with more versions coming, this should be replaced with an enum, where the first byte will encode (with standard strict encoding) a version number as an enum variant. For instance,

pub enum Issue {
    V0(IssueV0),
    V1(IssueV1)
}
pub struct IssueV0 { /*...*/ }
pub struct IssueV1 { /*...*/ }

meta: ContractMeta

Contract metadata.

codex: Codex

The codex under which the contract is issued and against which it must be validated.

genesis: Genesis

Genesis operation.

Implementations

impl Issue

pub fn contract_id(&self) -> ContractId

Computes contract id.

Contract id is a commitment to the contract issue information, which includes contract metadata, codex, and genesis operation.

pub fn codex_id(&self) -> CodexId

Compute codex id.

Shorthand for [Self::issue::codex_id()].

pub fn genesis_opid(&self) -> Opid

Computes the operation id of the genesis operation.

Equals to the Genesis::opid called with Self::contract_id as an argument.

Trait Implementations

impl Clone for Issue

fn clone(&self) -> Issue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommitEncode for Issue

type CommitmentId = ContractId

Type of the resulting commitment.

fn commit_encode(&self, e: &mut CommitEngine)

Encodes the data for the commitment by writing them directly into a std::io::Write writer instance

impl Debug for Issue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Issue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Issue

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for Issue

fn strict_decode(reader: &mut impl TypedRead) -> Result<Issue, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for Issue

fn strict_dumb() -> Issue

impl StrictEncode for Issue

fn strict_encode<W>(&self, writer: W) -> Result<W, Error>

where W: TypedWrite,

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictStruct for Issue

const ALL_FIELDS: &'static [&'static str]

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for Issue

const STRICT_LIB_NAME: &'static str = LIB_NAME_ULTRASONIC

fn strict_name() -> Option<TypeName>

impl Eq for Issue

impl StrictProduct for Issue