Struct StatePath

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

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

Implementations

impl<N: Network> StatePath<N>

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

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_id := Hash( transition_root || tcm )
                                                                                 |
                                                                          transition_path
                                                                                |
                                                                         transition_leaf

impl<N: Network> StatePath<N>

pub fn new_local( global_state_root: N::StateRoot, local_state_root: N::TransactionID, transaction_path: TransactionPath<N>, transaction_leaf: TransactionLeaf<N>, transition_root: Field<N>, tcm: Field<N>, transition_path: TransitionPath<N>, transition_leaf: TransitionLeaf<N>, ) -> Result<Self>

Initializes a new instance of StatePath.

pub fn from( global_state_root: N::StateRoot, block_path: BlockPath<N>, block_hash: N::BlockHash, previous_block_hash: N::BlockHash, header_root: Field<N>, header_path: HeaderPath<N>, header_leaf: HeaderLeaf<N>, transactions_path: TransactionsPath<N>, transaction_id: N::TransactionID, transaction_path: TransactionPath<N>, transaction_leaf: TransactionLeaf<N>, transition_root: Field<N>, tcm: Field<N>, transition_path: TransitionPath<N>, transition_leaf: TransitionLeaf<N>, ) -> Self

Initializes a new instance of StatePath.

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

Returns the global state root.

pub const fn block_path(&self) -> &BlockPath<N>

Returns the block path.

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

Returns the block hash.

pub const fn previous_block_hash(&self) -> N::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) -> &HeaderPath<N>

Returns the header path.

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

Returns the header leaf.

pub const fn transactions_path(&self) -> &TransactionsPath<N>

Returns the transactions path.

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

Returns the transaction ID.

pub const fn transaction_path(&self) -> &TransactionPath<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_root(&self) -> &Field<N>

Returns the transition root.

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

Returns the transition commitment.

pub const fn transition_path(&self) -> &TransitionPath<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 + Network> Clone for StatePath<N>

where N::StateRoot: Clone, N::BlockHash: Clone, N::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: Network> Debug for StatePath<N>

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

Formats the value using the given formatter.

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

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the state path from a string or bytes.

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

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

Writes the state path as a bech32m string.

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

fn read_le<R: Read>(reader: R) -> IoResult<Self>

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: Network> FromStr for StatePath<N>

fn from_str(state_path: &str) -> Result<Self, Self::Err>

Reads in the state path string.

type Err = Error

The associated error which can be returned from parsing.

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

fn parse(string: &str) -> ParserResult<'_, Self>

Parses a string into the state path.

impl<N: PartialEq + Network> PartialEq for StatePath<N>

where N::StateRoot: PartialEq, N::BlockHash: PartialEq, N::TransactionID: PartialEq,

fn eq(&self, other: &StatePath<N>) -> 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<N: Network> Serialize for StatePath<N>

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

Serializes the state path into string or bytes.

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

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes the path to a buffer.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

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

impl<N: Eq + Network> Eq for StatePath<N>

where N::StateRoot: Eq, N::BlockHash: Eq, N::TransactionID: Eq,

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