Struct Transition 

pub struct Transition {
    pub transition_id: u16,
    pub owned_inputs: Vec<StateRef>,
    pub owned_outputs: Vec<StateAssignment>,
    pub global_updates: Vec<GlobalState>,
    pub metadata: Vec<Metadata>,
    pub validation_script: Vec<u8>,
    pub signatures: Vec<Vec<u8>>,
}

A contract transition

A transition consumes existing state, executes validation logic (bytecode), and produces new state. It is authorized by consuming a single-use seal.

Fields

transition_id: u16

Unique transition ID (defined by the schema)

owned_inputs: Vec<StateRef>

Owned state inputs being consumed

owned_outputs: Vec<StateAssignment>

Owned state outputs being created

global_updates: Vec<GlobalState>

Global state updates

metadata: Vec<Metadata>

Transition metadata

validation_script: Vec<u8>

Validation bytecode (e.g., AluVM)

signatures: Vec<Vec<u8>>

Authorizing signatures

Implementations

impl Transition

pub fn new( transition_id: u16, owned_inputs: Vec<StateRef>, owned_outputs: Vec<StateAssignment>, global_updates: Vec<GlobalState>, metadata: Vec<Metadata>, validation_script: Vec<u8>, signatures: Vec<Vec<u8>>, ) -> Self

Create a new transition

pub fn hash(&self) -> Hash

Compute the transition hash

pub fn consumed_seals(&self) -> Vec<SealRef>

Get all seals consumed by this transition (from owned inputs)

pub fn assigned_seals(&self) -> Vec<SealRef>

Get all seals that receive new state from this transition

pub fn is_genesis_like(&self) -> bool

Check if this transition has no inputs (genesis-like transition)

pub fn is_destructive(&self) -> bool

Check if this transition destroys all state (no outputs)

pub fn to_dag_node(&self) -> DAGNode

Convert to a DAG node for backwards compatibility

Trait Implementations

impl Clone for Transition

fn clone(&self) -> Transition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transition

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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 Transition

impl StructuralPartialEq for Transition