Struct Transition

pub struct Transition {
    pub ffv: Ffv,
    pub contract_id: ContractId,
    pub transition_type: u16,
    pub metadata: Confined<Vec<u8>, amplify::::collection::confinement::SmallBlob::{constant#0}, amplify::::collection::confinement::SmallBlob::{constant#1}>,
    pub globals: GlobalState,
    pub inputs: Inputs,
    pub assignments: Assignments<BlindSeal<TxPtr>>,
    pub valencies: Valencies,
}

Fields

ffv: Ffv

contract_id: ContractId

transition_type: u16

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

globals: GlobalState

inputs: Inputs

assignments: Assignments<BlindSeal<TxPtr>>

valencies: Valencies

Implementations

impl Transition

pub fn prev_state(&self) -> &Inputs

Returns reference to information about the owned rights in form of Inputs wrapper structure which this operation updates with state transition (“parent owned rights”).

Trait Implementations

impl Clone for Transition

fn clone(&self) -> Transition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommitEncode for Transition

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 Transition

const TAG: [u8; 32]

type Id = OpId

Type of the resulting commitment.

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

Performs commitment to client-side-validated data

impl Conceal for Transition

type Concealed = Transition

The resulting confidential type concealing original data.

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

Performs conceal procedure returning confidential data concealing original data.

impl Debug for Transition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

Converts to this type from the input type.

impl Hash for Transition

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 Transition

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

impl Operation for Transition

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 Ord for Transition

fn cmp(&self, other: &Transition) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Transition

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

fn partial_cmp(&self, other: &Transition) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Transition

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 Transition

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

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

impl StrictDeserialize for Transition

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 Transition

fn strict_dumb() -> Transition

impl StrictEncode for Transition

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 Transition

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 Transition

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

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for Transition

const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB

fn strict_name() -> Option<TypeName>

impl Eq for Transition

impl StrictProduct for Transition

impl StructuralPartialEq for Transition