Struct Genesis 

pub struct Genesis {
    pub contract_id: Hash,
    pub schema_id: Hash,
    pub global_state: Vec<GlobalState>,
    pub owned_state: Vec<OwnedState>,
    pub metadata: Vec<Metadata>,
}

Contract genesis

The genesis is the root of every contract’s state history. It is referenced by the first transition and indirectly by all subsequent ones.

Fields

contract_id: Hash

Unique contract identifier (user-facing, e.g., “USDT-on-Bitcoin:1”)

schema_id: Hash

Schema identifier binding this genesis to a contract schema

global_state: Vec<GlobalState>

Initial global state values

owned_state: Vec<OwnedState>

Initial owned state assignments (e.g., initial token distribution)

metadata: Vec<Metadata>

Genesis metadata (issuance date, issuer info, etc.)

Implementations

impl Genesis

pub fn new( contract_id: Hash, schema_id: Hash, global_state: Vec<GlobalState>, owned_state: Vec<OwnedState>, metadata: Vec<Metadata>, ) -> Self

Create new genesis

pub fn hash(&self) -> Hash

Compute the genesis hash

This hash serves as the root commitment for all subsequent transitions.

pub fn state_count(&self) -> usize

Get the total count of all state items

pub fn global_states_of(&self, type_id: u16) -> Vec<&GlobalState>

Find global states by type ID

pub fn owned_states_of(&self, type_id: u16) -> Vec<&OwnedState>

Find owned states by type ID

Trait Implementations

impl Clone for Genesis

fn clone(&self) -> Genesis

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Genesis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Genesis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Genesis

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Genesis

impl StructuralPartialEq for Genesis