Struct snarkvm_wasm::program::StatePath

pub struct StatePath<N>where
    N: Network,{ /* private fields */ }

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

Implementations

impl<N> StatePath<N>where
    N: Network,

pub fn verify(
    &self,
    is_global: bool,
    local_state_root: Field<N>
) -> Result<(), Error>

Checks 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<N> StatePath<N>where
    N: Network,

pub fn new_local(
    global_state_root: <N as Network>::StateRoot,
    local_state_root: <N as Network>::TransactionID,
    transaction_path: MerklePath<N, _>,
    transaction_leaf: TransactionLeaf<N>,
    transition_path: MerklePath<N, _>,
    transition_leaf: TransitionLeaf<N>
) -> Result<StatePath<N>, Error>

Initializes a new instance of StatePath.

pub fn from(
    global_state_root: <N as Network>::StateRoot,
    block_path: MerklePath<N, _>,
    block_hash: <N as Network>::BlockHash,
    previous_block_hash: <N as Network>::BlockHash,
    header_root: Field<N>,
    header_path: MerklePath<N, _>,
    header_leaf: HeaderLeaf<N>,
    transactions_path: MerklePath<N, _>,
    transaction_id: <N as Network>::TransactionID,
    transaction_path: MerklePath<N, _>,
    transaction_leaf: TransactionLeaf<N>,
    transition_path: MerklePath<N, _>,
    transition_leaf: TransitionLeaf<N>
) -> StatePath<N>

Initializes a new instance of StatePath.

pub const fn global_state_root(&self) -> <N as Network>::StateRoot

Returns the global state root.

pub const fn block_path(&self) -> &MerklePath<N, _>

Returns the block path.

pub const fn block_hash(&self) -> <N as Network>::BlockHash

Returns the block hash.

pub const fn previous_block_hash(&self) -> <N as Network>::BlockHash

Returns the previous block hash.

pub const fn header_root(&self) -> &Field<N>

Returns the block header root.

pub const fn header_path(&self) -> &MerklePath<N, _>

Returns the header path.

pub const fn header_leaf(&self) -> &HeaderLeaf<N>

Returns the header leaf.

pub const fn transactions_path(&self) -> &MerklePath<N, _>

Returns the transactions path.

pub const fn transaction_id(&self) -> &<N as Network>::TransactionID

Returns the transaction ID.

pub const fn transaction_path(&self) -> &MerklePath<N, _>

Returns the Merkle path for the transaction leaf.

pub const fn transaction_leaf(&self) -> &TransactionLeaf<N>

Returns the transaction leaf.

pub const fn transition_path(&self) -> &MerklePath<N, _>

Returns the Merkle path for the transition leaf.

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

Returns the transition leaf.

Trait Implementations

impl<N> Clone for StatePath<N>where
    N: Clone + Network,
    <N as Network>::StateRoot: Clone,
    <N as Network>::BlockHash: Clone,
    <N as Network>::TransactionID: Clone,

fn clone(&self) -> StatePath<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for StatePath<N>where
    N: Network,

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

Formats the value using the given formatter.

impl<'de, N> Deserialize<'de> for StatePath<N>where
    N: Network,

fn deserialize<D>(
    deserializer: D
) -> Result<StatePath<N>, <D as Deserializer<'de>>::Error>where
    D: Deserializer<'de>,

Deserializes the state path from a string or bytes.

impl<N> Display for StatePath<N>where
    N: Network,

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

Writes the state path as a bech32m string.

impl<N> FromBytes for StatePath<N>where
    N: Network,

fn read_le<R>(reader: R) -> Result<StatePath<N>, Error>where
    R: Read,

Reads the path from a buffer.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>where
    Self: Sized,

Returns Self from a byte array in little-endian order.

impl<N> FromStr for StatePath<N>where
    N: Network,

fn from_str(
    state_path: &str
) -> Result<StatePath<N>, <StatePath<N> as FromStr>::Err>

Reads in the state path string.

type Err = Error

The associated error which can be returned from parsing.

impl<N> Parser for StatePath<N>where
    N: Network,

fn parse(string: &str) -> Result<(&str, StatePath<N>), Err<VerboseError<&str>>>

Parses a string into the state path.

impl<N> PartialEq<StatePath<N>> for StatePath<N>where
    N: PartialEq<N> + Network,
    <N as Network>::StateRoot: PartialEq<<N as Network>::StateRoot>,
    <N as Network>::BlockHash: PartialEq<<N as Network>::BlockHash>,
    <N as Network>::TransactionID: PartialEq<<N as Network>::TransactionID>,

fn eq(&self, other: &StatePath<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> Serialize for StatePath<N>where
    N: Network,

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

Serializes the state path into string or bytes.

impl<N> ToBytes for StatePath<N>where
    N: Network,

fn write_le<W>(&self, writer: W) -> Result<(), Error>where
    W: Write,

Writes the path to a buffer.

fn to_bytes_le(&self) -> Result<Vec<u8, Global>, Error>where
    Self: Sized,

Returns self as a byte array in little-endian order.

impl<N> Eq for StatePath<N>where
    N: Eq + Network,
    <N as Network>::StateRoot: Eq,
    <N as Network>::BlockHash: Eq,
    <N as Network>::TransactionID: Eq,

impl<N> StructuralEq for StatePath<N>where
    N: Network,

impl<N> StructuralPartialEq for StatePath<N>where
    N: Network,