Struct StatePath

pub struct StatePath<A: Aleo> { /* private fields */ }

The state path proves existence of the transition leaf to either a global or local state root.

Implementations

impl<A: Aleo> StatePath<A>

pub fn verify( &self, is_global: &Boolean<A>, local_state_root: &Field<A>, ) -> Boolean<A>

Returns true if the state path is valid.

Parameters

• local_state_root is the local transaction root for the current execution.
• is_global is a boolean indicating whether this is a global or local state root.

Diagram

The [[ ]] notation is used to denote public inputs.

 [[ global_state_root ]]
          |
     block_path
         |
    block_hash := Hash( previous_block_hash || header_root )
                                                    |
                                               header_path
                                                   |
                                              header_leaf
                                                  |
                                           transactions_path          [[ local_state_root ]]
                                                 |                               |
                                              (true) ------ is_global ------ (false)
                                                                |
                                                         transaction_id
                                                               |
                                                       transaction_path
                                                              |
                                                      transaction_leaf
                                                             |
                                                     transition_id := Hash( transition_root || tcm )
                                                                                 |
                                                                          transition_path
                                                                                |
                                                                         transition_leaf

impl<A: Aleo> StatePath<A>

pub const fn transition_leaf(&self) -> &TransitionLeaf<A>

Returns the transition leaf.

Trait Implementations

impl<A: Aleo> Eject for StatePath<A>

fn eject_mode(&self) -> Mode

Ejects the mode of the state path.

fn eject_value(&self) -> Self::Primitive

Ejects the state path.

type Primitive = StatePath<<A as Environment>::Network>

fn eject(&self) -> (Mode, Self::Primitive)

Ejects the mode and primitive value of the circuit type.

fn is_constant(&self) -> bool

Returns true if the circuit is a constant.

fn is_public(&self) -> bool

Returns true if the circuit is a public.

fn is_private(&self) -> bool

Returns true if the circuit is a private.

impl<A: Aleo> Inject for StatePath<A>

fn new(mode: Mode, state_path: Self::Primitive) -> Self

Initializes a new ciphertext circuit from a primitive.

type Primitive = StatePath<<A as Environment>::Network>

fn constant(value: Self::Primitive) -> Self

where Self: Sized,

Initializes a constant of the given primitive value.