Struct storage_proofs_core::merkle::MerkleTreeWrapper

pub struct MerkleTreeWrapper<H: Hasher, S: Store<<H as Hasher>::Domain>, U: PoseidonArity, V: PoseidonArity = U0, W: PoseidonArity = U0> {
    pub inner: MerkleTree<<H as Hasher>::Domain, <H as Hasher>::Function, S, U, V, W>,
    pub h: PhantomData<H>,
}

Fields

inner: MerkleTree<<H as Hasher>::Domain, <H as Hasher>::Function, S, U, V, W>

h: PhantomData<H>

Implementations

impl<H: Hasher, S: Store<<H as Hasher>::Domain>, U: PoseidonArity, V: PoseidonArity, W: PoseidonArity> MerkleTreeWrapper<H, S, U, V, W>

pub fn new<I: IntoIterator<Item = H::Domain>>(data: I) -> Result<Self>

pub fn new_with_config<I: IntoIterator<Item = H::Domain>>( data: I, config: StoreConfig, ) -> Result<Self>

pub fn from_data_with_config<O: Hashable<H::Function>, I: IntoIterator<Item = O>>( data: I, config: StoreConfig, ) -> Result<Self>

pub fn from_data_store(data: S, leafs: usize) -> Result<Self>

pub fn from_byte_slice_with_config( data: &[u8], config: StoreConfig, ) -> Result<Self>

pub fn from_tree_slice(data: &[u8], leafs: usize) -> Result<Self>

pub fn from_tree_slice_with_config( data: &[u8], leafs: usize, config: StoreConfig, ) -> Result<Self>

pub fn from_trees( trees: Vec<MerkleTreeWrapper<H, S, U, U0, U0>>, ) -> Result<Self>

pub fn from_sub_trees( trees: Vec<MerkleTreeWrapper<H, S, U, V, U0>>, ) -> Result<Self>

pub fn from_sub_trees_as_trees( trees: Vec<MerkleTreeWrapper<H, S, U, U0, U0>>, ) -> Result<Self>

pub fn from_slices( tree_data: &[&[u8]], leafs: usize, ) -> Result<MerkleTreeWrapper<H, S, U, V, U0>>

pub fn from_slices_with_configs( tree_data: &[&[u8]], leafs: usize, configs: &[StoreConfig], ) -> Result<Self>

pub fn from_stores(leafs: usize, stores: Vec<S>) -> Result<Self>

pub fn from_store_configs(leafs: usize, configs: &[StoreConfig]) -> Result<Self>

pub fn from_store_configs_and_replica( leafs: usize, configs: &[StoreConfig], replica_config: &ReplicaConfig, ) -> Result<LCTree<H, U, V, W>>

pub fn from_sub_tree_store_configs( leafs: usize, configs: &[StoreConfig], ) -> Result<Self>

pub fn try_from_iter<I: IntoIterator<Item = Result<H::Domain>>>( into: I, ) -> Result<Self>

pub fn from_sub_tree_store_configs_and_replica( leafs: usize, configs: &[StoreConfig], replica_config: &ReplicaConfig, ) -> Result<LCTree<H, U, V, W>>

pub fn try_from_iter_with_config<I: IntoIterator<Item = Result<H::Domain>>>( into: I, config: StoreConfig, ) -> Result<Self>

pub fn from_par_iter<I>(par_iter: I) -> Result<Self>

where I: IntoParallelIterator<Item = H::Domain>, I::Iter: IndexedParallelIterator,

pub fn from_par_iter_with_config<I>( par_iter: I, config: StoreConfig, ) -> Result<Self>

where I: IntoParallelIterator<Item = H::Domain>, I::Iter: IndexedParallelIterator,

Methods from Deref<Target = MerkleTree<H::Domain, H::Function, S, BaseArity, SubTreeArity, TopTreeArity>>

pub fn set_external_reader_path(&mut self, path: &Path) -> Result<(), Error>

Given a pathbuf, instantiate an ExternalReader and set it for the LevelCacheStore.

pub fn gen_proof(&self, i: usize) -> Result<Proof<E, BaseTreeArity>, Error>

Generate merkle tree inclusion proof for leaf i

pub fn gen_cached_proof( &self, i: usize, rows_to_discard: Option<usize>, ) -> Result<Proof<E, BaseTreeArity>, Error>

Generate merkle tree inclusion proof for leaf i by first building a partial tree (returned) along with the proof. ‘rows_to_discard’ is an option that will be used if set (even if it may cause an error), otherwise a reasonable default is chosen.

Return value is a Result tuple of the proof and the partial tree that was constructed.

pub fn root(&self) -> E

Returns merkle root

pub fn len(&self) -> usize

Returns number of elements in the tree.

pub fn compact( &mut self, config: StoreConfig, store_version: u32, ) -> Result<bool, Error>

Truncates the data for later access via LevelCacheStore interface.

pub fn reinit(&mut self) -> Result<(), Error>

pub fn delete(&self, config: StoreConfig) -> Result<(), Error>

Removes the backing store for this merkle tree.

pub fn is_empty(&self) -> bool

Returns true if the store contains no elements.

pub fn row_count(&self) -> usize

Returns row_count of the tree

pub fn leafs(&self) -> usize

Returns original number of elements the tree was built upon.

pub fn data(&self) -> Option<&S>

Returns data reference

pub fn read_at(&self, i: usize) -> Result<E, Error>

Returns merkle leaf at index i

pub fn read_range(&self, start: usize, end: usize) -> Result<Vec<E>, Error>

pub fn read_range_into( &self, start: usize, end: usize, buf: &mut [u8], ) -> Result<(), Error>

pub fn read_into(&self, pos: usize, buf: &mut [u8]) -> Result<(), Error>

Reads into a pre-allocated slice (for optimization purposes).

Trait Implementations

impl<H: Hasher, S: Store<<H as Hasher>::Domain>, BaseArity: PoseidonArity, SubTreeArity: PoseidonArity, TopTreeArity: PoseidonArity> Debug for MerkleTreeWrapper<H, S, BaseArity, SubTreeArity, TopTreeArity>

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

Formats the value using the given formatter.

impl<H: Hasher, S: Store<<H as Hasher>::Domain>, BaseArity: PoseidonArity, SubTreeArity: PoseidonArity, TopTreeArity: PoseidonArity> DerefMut for MerkleTreeWrapper<H, S, BaseArity, SubTreeArity, TopTreeArity>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<H: Hasher, S: Store<<H as Hasher>::Domain>, U: PoseidonArity, V: PoseidonArity, W: PoseidonArity> From<MerkleTree<<H as Hasher>::Domain, <H as Hasher>::Function, S, U, V, W>> for MerkleTreeWrapper<H, S, U, V, W>

fn from( tree: MerkleTree<<H as Hasher>::Domain, <H as Hasher>::Function, S, U, V, W>, ) -> Self

Converts to this type from the input type.

impl<H: 'static + Hasher, S: Store<<H as Hasher>::Domain>, U: 'static + PoseidonArity, V: 'static + PoseidonArity, W: 'static + PoseidonArity> MerkleTreeTrait for MerkleTreeWrapper<H, S, U, V, W>

type Arity = U

type SubTreeArity = V

type TopTreeArity = W

type Hasher = H

type Store = S

type Proof = MerkleProof<<MerkleTreeWrapper<H, S, U, V, W> as MerkleTreeTrait>::Hasher, <MerkleTreeWrapper<H, S, U, V, W> as MerkleTreeTrait>::Arity, <MerkleTreeWrapper<H, S, U, V, W> as MerkleTreeTrait>::SubTreeArity, <MerkleTreeWrapper<H, S, U, V, W> as MerkleTreeTrait>::TopTreeArity>

fn display() -> String

Print a unique name for this configuration.

fn root(&self) -> <Self::Hasher as Hasher>::Domain

Returns the root hash of the tree.

fn gen_proof(&self, i: usize) -> Result<Self::Proof>

Creates a merkle proof of the node at the given index.

fn gen_cached_proof( &self, i: usize, rows_to_discard: Option<usize>, ) -> Result<Self::Proof>

fn row_count(&self) -> usize

fn leaves(&self) -> usize

fn from_merkle( tree: MerkleTree<<Self::Hasher as Hasher>::Domain, <Self::Hasher as Hasher>::Function, Self::Store, Self::Arity, Self::SubTreeArity, Self::TopTreeArity>, ) -> Self

impl<H: Hasher, S: Store<<H as Hasher>::Domain>, BaseArity: PoseidonArity, SubTreeArity: PoseidonArity, TopTreeArity: PoseidonArity> Deref for MerkleTreeWrapper<H, S, BaseArity, SubTreeArity, TopTreeArity>

type Target = MerkleTree<<H as Hasher>::Domain, <H as Hasher>::Function, S, BaseArity, SubTreeArity, TopTreeArity>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.