Struct snarkvm_circuit::StatePath

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

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

Implementations

impl<A> StatePath<A>where
    A: Aleo,

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_path
                                                            |
                                                   transition_leaf

impl<A> StatePath<A>where
    A: Aleo,

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

Returns the transition leaf.

Trait Implementations

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

fn eject_mode(&self) -> Mode

Ejects the mode of the state path.

fn eject_value(&self) -> <StatePath<A> as Eject>::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> Inject for StatePath<A>where
    A: Aleo,

fn new(
    mode: Mode,
    state_path: <StatePath<A> as Inject>::Primitive
) -> StatePath<A>

Initializes a new ciphertext circuit from a primitive.

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

fn constant(value: Self::Primitive) -> Selfwhere
    Self: Sized,

Initializes a constant of the given primitive value.