Struct Genesis

pub struct Genesis {
    pub ffv: Ffv,
    pub schema_id: SchemaId,
    pub chain: Chain,
    pub metadata: Confined<Vec<u8>, amplify::::collection::confinement::SmallBlob::{constant#0}, amplify::::collection::confinement::SmallBlob::{constant#1}>,
    pub globals: GlobalState,
    pub assignments: Assignments<BlindSeal<Txid>>,
    pub valencies: Valencies,
}

Fields

ffv: Ffv

schema_id: SchemaId

chain: Chain

metadata: Confined<Vec<u8>, amplify::::collection::confinement::SmallBlob::{constant#0}, amplify::::collection::confinement::SmallBlob::{constant#1}>

globals: GlobalState

assignments: Assignments<BlindSeal<Txid>>

valencies: Valencies

Trait Implementations

impl Clone for Genesis

fn clone(&self) -> Genesis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommitEncode for Genesis

fn commit_encode(&self, e: &mut impl Write)

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

impl CommitmentId for Genesis

const TAG: [u8; 32]

type Id = ContractId

Type of the resulting commitment.

fn commitment_id(&self) -> Self::Id

Performs commitment to client-side-validated data

impl Conceal for Genesis

type Concealed = Genesis

The resulting confidential type concealing original data.

fn conceal(&self) -> <Genesis as Conceal>::Concealed

Performs conceal procedure returning confidential data concealing original data.

impl Debug for Genesis

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'op> From<&'op Genesis> for OpRef<'op>

fn from(v: &'op Genesis) -> OpRef<'op>

Converts to this type from the input type.

impl Hash for Genesis

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl MergeReveal for Genesis

fn merge_reveal(self, other: Self) -> Result<Self, MergeRevealError>

impl Operation for Genesis

fn op_type(&self) -> OpType

Returns type of the operation (see OpType). Unfortunately, this can’t be just a const, since it will break our ability to convert concrete Node types into &dyn Node (entities implementing traits with const definitions can’t be made into objects)

fn full_type(&self) -> OpFullType

Returns full contract operation type information

fn id(&self) -> OpId

Returns OpId, which is a hash of this operation commitment serialization

fn contract_id(&self) -> ContractId

Returns ContractId this operation belongs to.

fn transition_type(&self) -> Option<u16>

Returns Option::Some(TransitionType) for transitions or Option::None for genesis and extension operation types

fn extension_type(&self) -> Option<u16>

Returns Option::Some(ExtensionType) for extension nodes or Option::None for genesis and state transitions

fn metadata( &self, ) -> &Confined<Vec<u8>, amplify::::collection::confinement::SmallBlob::{constant#0}, amplify::::collection::confinement::SmallBlob::{constant#1}>

Returns metadata associated with the operation, if any.

fn globals(&self) -> &GlobalState

Returns reference to a full set of metadata (in form of GlobalState wrapper structure) for the contract operation.

fn valencies(&self) -> &Valencies

fn assignments(&self) -> AssignmentsRef<'_>

fn assignments_by_type(&self, t: u16) -> Option<TypedAssigns<BlindSeal<TxPtr>>>

fn inputs(&self) -> Inputs

For genesis and public state extensions always returns an empty list. While public state extension do have parent nodes, they do not contain indexed rights.

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for Genesis

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

fn strict_read(lim: usize, reader: impl Read) -> Result<Self, DecodeError>

impl StrictDeserialize for Genesis

fn from_strict_serialized<const MAX: usize>( ast_data: Confined<Vec<u8>, 0, MAX>, ) -> Result<Self, DeserializeError>

fn strict_deserialize_from_file<const MAX: usize>( path: impl AsRef<Path>, ) -> Result<Self, DeserializeError>

impl StrictDumb for Genesis

fn strict_dumb() -> Genesis

impl StrictEncode for Genesis

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

where W: TypedWrite,

fn strict_write(&self, lim: usize, writer: impl Write) -> Result<usize, Error>

impl StrictSerialize for Genesis

fn strict_serialized_len(&self) -> Result<usize, Error>

fn to_strict_serialized<const MAX: usize>( &self, ) -> Result<Confined<Vec<u8>, 0, MAX>, SerializeError>

fn strict_serialize_to_file<const MAX: usize>( &self, path: impl AsRef<Path>, ) -> Result<(), SerializeError>

impl StrictStruct for Genesis

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

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for Genesis

const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB

fn strict_name() -> Option<TypeName>

impl Eq for Genesis

impl StrictProduct for Genesis

impl StructuralPartialEq for Genesis