From 3b046f54128058276df5843a7413c31b8c288a71 Mon Sep 17 00:00:00 2001 From: ggutoski Date: Wed, 4 Sep 2024 15:41:46 +0000 Subject: [PATCH] deploy: ae16b4ce27c90555078f842804de1a24d0c57c1f --- help.html | 2 +- jf_vid/advz/index.html | 2 +- jf_vid/advz/struct.AdvzInternal.html | 32 +++--- jf_vid/advz/struct.Common.html | 38 +++---- jf_vid/advz/struct.Share.html | 36 +++--- jf_vid/advz/trait.MaybeGPU.html | 6 +- jf_vid/advz/type.Advz.html | 12 +- jf_vid/trait.VidScheme.html | 2 +- search-index.js | 2 +- settings.html | 2 +- src/jf_vid/advz.rs.html | 104 ++++++++++++++---- trait.impl/core/marker/trait.Unpin.js | 2 +- .../panic/unwind_safe/trait.RefUnwindSafe.js | 2 +- .../panic/unwind_safe/trait.UnwindSafe.js | 2 +- type.impl/jf_vid/advz/struct.AdvzInternal.js | 2 +- 15 files changed, 156 insertions(+), 90 deletions(-) diff --git a/help.html b/help.html index 7889c5203..ae5d60832 100644 --- a/help.html +++ b/help.html @@ -1 +1 @@ -Help

Rustdoc help

Back
\ No newline at end of file +Help

Rustdoc help

Back
\ No newline at end of file diff --git a/jf_vid/advz/index.html b/jf_vid/advz/index.html index d39487ffd..cb37d3b0b 100644 --- a/jf_vid/advz/index.html +++ b/jf_vid/advz/index.html @@ -1,4 +1,4 @@ -jf_vid::advz - Rust

Module jf_vid::advz

source ·
Expand description

Implementation of Verifiable Information Dispersal (VID) from https://eprint.iacr.org/2021/1500.

+jf_vid::advz - Rust

Module jf_vid::advz

source ·
Expand description

Implementation of Verifiable Information Dispersal (VID) from https://eprint.iacr.org/2021/1500.

advz named for the authors Alhaddad-Duan-Varia-Zhang.

Modules§

Structs§

Traits§

-

Implementations§

source§

impl<E, H> AdvzInternal<E, H, ()>
where - E: Pairing,

source

pub fn new( +

Implementations§

source§

impl<E, H> AdvzInternal<E, H, ()>
where + E: Pairing,

source

pub fn new( num_storage_nodes: u32, recovery_threshold: u32, srs: impl Borrow<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::SRS>, @@ -29,7 +29,7 @@

§Errors
  • num_storage_nodes < recovery_threshold
  • TEMPORARY recovery_threshold is not a power of two github issue
    • -
    source

    pub fn with_multiplicity( +

    source

    pub fn with_multiplicity( num_storage_nodes: u32, recovery_threshold: u32, max_multiplicity: u32, @@ -44,13 +44,13 @@

    §Errors
    • TEMPORARY max_multiplicity is not a power of two github issue
    -

    Trait Implementations§

    source§

    impl<E, H: Clone, T> Clone for AdvzInternal<E, H, T>
    where +

    Trait Implementations§

    source§

    impl<E, H: Clone, T> Clone for AdvzInternal<E, H, T>
    where E: Pairing + Clone, - T: Sync + Clone,

    source§

    fn clone(&self) -> AdvzInternal<E, H, T>

    Returns a copy of the value. Read more
    1.0.0 · source§

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

    Performs copy-assignment from source. Read more
    source§

    impl<E, H: Debug, T> Debug for AdvzInternal<E, H, T>
    where + T: Sync + Clone,

    source§

    fn clone(&self) -> AdvzInternal<E, H, T>

    Returns a copy of the value. Read more
    1.0.0 · source§

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

    Performs copy-assignment from source. Read more
    source§

    impl<E, H: Debug, T> Debug for AdvzInternal<E, H, T>
    where E: Pairing + Debug, - T: Sync + Debug,

    source§

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

    Formats the value using the given formatter. Read more
    source§

    impl<E, H: PartialEq, T> PartialEq for AdvzInternal<E, H, T>
    where + T: Sync + Debug,

    source§

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

    Formats the value using the given formatter. Read more
    source§

    impl<E, H: PartialEq, T> PartialEq for AdvzInternal<E, H, T>
    where E: Pairing + PartialEq, - T: Sync + PartialEq,

    source§

    fn eq(&self, other: &AdvzInternal<E, H, T>) -> bool

    This method tests for self and other values to be equal, and is used + T: Sync + PartialEq,
    source§

    fn eq(&self, other: &AdvzInternal<E, H, T>) -> bool

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

    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.
    source§

    impl<E, H, T> PayloadProver<LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>> for AdvzInternal<E, H, T>
    where E: Pairing, @@ -93,28 +93,28 @@
    §Errors
    data: &Self::PrecomputeData, ) -> VidResult<VidDisperse<Self>>
    where B: AsRef<[u8]>,

    Similar to VidScheme::disperse but takes as input additional -data for more efficient computation and faster disersal.
    source§

    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where +data for more efficient computation and faster disersal.

    source§

    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where E: Pairing, H: HasherDigest, T: Sync, - AdvzInternal<E, H, T>: MaybeGPU<E>,

    §

    type Commit = HasherNode<H>

    Payload commitment.
    §

    type Share = Share<E, H>

    Share-specific data sent to a storage node.
    §

    type Common = Common<E, H>

    Common data sent to all storage nodes.
    source§

    fn commit_only<B>(&mut self, payload: B) -> VidResult<Self::Commit>
    where - B: AsRef<[u8]>,

    Compute a payload commitment
    source§

    fn disperse<B>(&mut self, payload: B) -> VidResult<VidDisperse<Self>>
    where - B: AsRef<[u8]>,

    Compute shares to send to the storage nodes
    source§

    fn verify_share( + AdvzInternal<E, H, T>: MaybeGPU<E>,

    §

    type Commit = HasherNode<H>

    Payload commitment.
    §

    type Share = Share<E, H>

    Share-specific data sent to a storage node.
    §

    type Common = Common<E, H>

    Common data sent to all storage nodes.
    source§

    fn commit_only<B>(&mut self, payload: B) -> VidResult<Self::Commit>
    where + B: AsRef<[u8]>,

    Compute a payload commitment
    source§

    fn disperse<B>(&mut self, payload: B) -> VidResult<VidDisperse<Self>>
    where + B: AsRef<[u8]>,

    Compute shares to send to the storage nodes
    source§

    fn verify_share( &self, share: &Self::Share, common: &Self::Common, commit: &Self::Commit, ) -> VidResult<Result<(), ()>>

    Verify a share. Used by both storage node and retrieval client. Why is return type a nested Result? See https://sled.rs/errors -Returns: Read more
    source§

    fn recover_payload( +Returns: Read more

    source§

    fn recover_payload( &self, shares: &[Self::Share], common: &Self::Common, ) -> VidResult<Vec<u8>>

    Recover payload from shares. -Do not verify shares or check recovered payload against anything.
    source§

    fn is_consistent(commit: &Self::Commit, common: &Self::Common) -> VidResult<()>

    Check that a VidScheme::Common is consistent with a -VidScheme::Commit. Read more
    source§

    fn get_payload_byte_len(common: &Self::Common) -> u32

    Extract the payload byte length data from a VidScheme::Common.
    source§

    fn get_num_storage_nodes(common: &Self::Common) -> u32

    Extract the number of storage nodes from a VidScheme::Common.
    source§

    fn get_multiplicity(common: &Self::Common) -> u32

    Extract the number of poly evals per share VidScheme::Common.
    source§

    impl<E, H: Eq, T> Eq for AdvzInternal<E, H, T>
    where +Do not verify shares or check recovered payload against anything.
    source§

    fn is_consistent(commit: &Self::Commit, common: &Self::Common) -> VidResult<()>

    Check that a VidScheme::Common is consistent with a +VidScheme::Commit. Read more
    source§

    fn get_payload_byte_len(common: &Self::Common) -> u32

    Extract the payload byte length data from a VidScheme::Common.
    source§

    fn get_num_storage_nodes(common: &Self::Common) -> u32

    Extract the number of storage nodes from a VidScheme::Common.
    source§

    fn get_multiplicity(common: &Self::Common) -> u32

    Extract the number of poly evals per share VidScheme::Common.
    source§

    impl<E, H: Eq, T> Eq for AdvzInternal<E, H, T>
    where E: Pairing + Eq, - T: Sync + Eq,

    source§

    impl<E, H, T> StructuralPartialEq for AdvzInternal<E, H, T>
    where + T: Sync + Eq,

    source§

    impl<E, H, T> StructuralPartialEq for AdvzInternal<E, H, T>
    where E: Pairing, T: Sync,

    Auto Trait Implementations§

    §

    impl<E, H, T> Freeze for AdvzInternal<E, H, T>
    where <E as Pairing>::G1Affine: Freeze, diff --git a/jf_vid/advz/struct.Common.html b/jf_vid/advz/struct.Common.html index 335aa3cdd..eccfbb629 100644 --- a/jf_vid/advz/struct.Common.html +++ b/jf_vid/advz/struct.Common.html @@ -1,9 +1,9 @@ -Common in jf_vid::advz - Rust

    Struct jf_vid::advz::Common

    source · 
    pub struct Common<E, H>
    where
+Common in jf_vid::advz - Rust
    Struct jf_vid::advz::Common
    source · 
    pub struct Common<E, H>
    where
     E: Pairing,
     H: HasherDigest,
    { /* private fields */ }
    Expand description
    The VidScheme::Common type for Advz.
    
-
    Trait Implementations§
    source§
    impl<E, H> CanonicalDeserialize for Common<E, H>
    where
+
    Trait Implementations§
    source§
    impl<E, H> CanonicalDeserialize for Common<E, H>
    where
     E: Pairing,
-    H: HasherDigest,
    source§
    fn deserialize_with_mode<R: Read>(
+    H: HasherDigest,

    source§

    fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, @@ -15,39 +15,39 @@ R: Read,

    §

    fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>
    where - R: Read,

    source§

    impl<E, H> CanonicalSerialize for Common<E, H>
    where + R: Read,

    source§

    impl<E, H> CanonicalSerialize for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn serialize_with_mode<W: Write>( + H: HasherDigest,

    source§

    fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, -) -> Result<(), SerializationError>

    The general serialize method that takes in customization flags.
    source§

    fn serialized_size(&self, compress: Compress) -> usize

    §

    fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>
    where +) -> Result<(), SerializationError>

    The general serialize method that takes in customization flags.
    source§

    fn serialized_size(&self, compress: Compress) -> usize

    §

    fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>
    where W: Write,

    §

    fn compressed_size(&self) -> usize

    §

    fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>
    where - W: Write,

    §

    fn uncompressed_size(&self) -> usize

    source§

    impl<E, H> Clone for Common<E, H>
    where + W: Write,

    §

    fn uncompressed_size(&self) -> usize

    source§

    impl<E, H> Clone for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

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

    Performs copy-assignment from source. Read more
    source§

    impl<E, H> Debug for Common<E, H>
    where + H: HasherDigest,

    source§

    fn clone(&self) -> Self

    Returns a copy of the value. Read more
    1.0.0 · source§

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

    Performs copy-assignment from source. Read more
    source§

    impl<E, H> Debug for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

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

    Formats the value using the given formatter. Read more
    source§

    impl<'de, E, H> Deserialize<'de> for Common<E, H>
    where + H: HasherDigest,

    source§

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

    Formats the value using the given formatter. Read more
    source§

    impl<'de, E, H> Deserialize<'de> for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
    where - __D: Deserializer<'de>,

    Deserialize this value from the given Serde deserializer. Read more
    source§

    impl<E, H> Hash for Common<E, H>
    where + H: HasherDigest,

    source§

    fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
    where + __D: Deserializer<'de>,

    Deserialize this value from the given Serde deserializer. Read more
    source§

    impl<E, H> Hash for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn hash<__HEH>(&self, __state: &mut __HEH)
    where + H: HasherDigest,

    source§

    fn hash<__HEH>(&self, __state: &mut __HEH)
    where __HEH: Hasher,

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where H: Hasher, - Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<E, H> PartialEq for Common<E, H>
    where + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl<E, H> PartialEq for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn eq(&self, other: &Self) -> bool

    This method tests for self and other values to be equal, and is used + H: HasherDigest,
    source§

    fn eq(&self, other: &Self) -> bool

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

    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.
    source§

    impl<E, H> Serialize for Common<E, H>
    where +sufficient, and should not be overridden without very good reason.

    source§

    impl<E, H> Serialize for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
    where - __S: Serializer,

    Serialize this value into the given Serde serializer. Read more
    source§

    impl<E, H> Valid for Common<E, H>
    where + H: HasherDigest,

    source§

    fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
    where + __S: Serializer,

    Serialize this value into the given Serde serializer. Read more
    source§

    impl<E, H> Valid for Common<E, H>
    where E: Pairing, - H: HasherDigest,

    source§

    fn check(&self) -> Result<(), SerializationError>

    source§

    fn batch_check<'a>( + H: HasherDigest,

    source§

    fn check(&self) -> Result<(), SerializationError>

    source§

    fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>
    where - Self: 'a,

    source§

    impl<E, H> Eq for Common<E, H>
    where + Self: 'a,

    source§

    impl<E, H> Eq for Common<E, H>
    where E: Pairing, H: HasherDigest,

    Auto Trait Implementations§

    §

    impl<E, H> Freeze for Common<E, H>
    where <H as HasherDigest>::Bar: Freeze,

    §

    impl<E, H> RefUnwindSafe for Common<E, H>
    where diff --git a/jf_vid/advz/struct.Share.html b/jf_vid/advz/struct.Share.html index f7e67c298..378406ba9 100644 --- a/jf_vid/advz/struct.Share.html +++ b/jf_vid/advz/struct.Share.html @@ -1,39 +1,39 @@ -Share in jf_vid::advz - Rust

    Struct jf_vid::advz::Share

    source · 
    pub struct Share<E, H>
    where
+Share in jf_vid::advz - Rust
    Struct jf_vid::advz::Share
    source · 
    pub struct Share<E, H>
    where
     E: Pairing,
     H: HasherDigest,
    { /* private fields */ }
    Expand description
    The VidScheme::Share type for Advz.
    
-
    Trait Implementations§
    source§
    impl<E, H> Clone for Share<E, H>
    where
+
    Trait Implementations§
    source§
    impl<E, H> Clone for Share<E, H>
    where
     E: Pairing,
-    H: HasherDigest,
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<E, H> Debug for Share<E, H>
    where
+    H: HasherDigest,
    source§
    fn clone(&self) -> Self
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    source§
    impl<E, H> Debug for Share<E, H>
    where
     E: Pairing,
-    H: HasherDigest,
    source§
    fn fmt(&self, __f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'de, E, H> Deserialize<'de> for Share<E, H>
    where
+    H: HasherDigest,
    source§
    fn fmt(&self, __f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    source§
    impl<'de, E, H> Deserialize<'de> for Share<E, H>
    where
     E: Pairing,
     H: HasherDigest,
-    Output<H>: Serialize + for<'a> Deserialize<'a>,
    source§
    fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
    where
-    __D: Deserializer<'de>,
    Deserialize this value from the given Serde deserializer. Read more
    source§
    impl<E, H> Hash for Share<E, H>
    where
+    Output<H>: Serialize + for<'a> Deserialize<'a>,
    source§
    fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
    where
+    __D: Deserializer<'de>,
    Deserialize this value from the given Serde deserializer. Read more
    source§
    impl<E, H> Hash for Share<E, H>
    where
     E: Pairing,
-    H: HasherDigest,
    source§
    fn hash<__HEH>(&self, __state: &mut __HEH)
    where
+    H: HasherDigest,
    source§
    fn hash<__HEH>(&self, __state: &mut __HEH)
    where
     __HEH: Hasher,
    Feeds this value into the given Hasher. Read more
    1.3.0 · source§
    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
     H: Hasher,
-    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<E, H> PartialEq for Share<E, H>
    where
+    Self: Sized,
    Feeds a slice of this type into the given Hasher. Read more
    source§
    impl<E, H> PartialEq for Share<E, H>
    where
     E: Pairing,
-    H: HasherDigest,
    source§
    fn eq(&self, other: &Self) -> bool
    This method tests for self and other values to be equal, and is used
+    H: HasherDigest,

    source§

    fn eq(&self, other: &Self) -> bool

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

    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.
    source§

    impl<E, H> Serialize for Share<E, H>
    where +sufficient, and should not be overridden without very good reason.

    source§

    impl<E, H> Serialize for Share<E, H>
    where E: Pairing, H: HasherDigest, - Output<H>: Serialize + for<'a> Deserialize<'a>,

    source§

    fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
    where - __S: Serializer,

    Serialize this value into the given Serde serializer. Read more
    source§

    impl<E, H> Eq for Share<E, H>
    where + Output<H>: Serialize + for<'a> Deserialize<'a>,

    source§

    fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
    where + __S: Serializer,

    Serialize this value into the given Serde serializer. Read more
    source§

    impl<E, H> Eq for Share<E, H>
    where E: Pairing, H: HasherDigest,

    Auto Trait Implementations§

    §

    impl<E, H> Freeze for Share<E, H>

    §

    impl<E, H> RefUnwindSafe for Share<E, H>
    where - <E as Pairing>::ScalarField: RefUnwindSafe, <E as Pairing>::G1Affine: RefUnwindSafe, - <H as HasherDigest>::Bar: RefUnwindSafe,

    §

    impl<E, H> Send for Share<E, H>

    §

    impl<E, H> Sync for Share<E, H>

    §

    impl<E, H> Unpin for Share<E, H>
    where - <E as Pairing>::ScalarField: Unpin, + <H as HasherDigest>::Bar: RefUnwindSafe, + <E as Pairing>::ScalarField: RefUnwindSafe,

    §

    impl<E, H> Send for Share<E, H>

    §

    impl<E, H> Sync for Share<E, H>

    §

    impl<E, H> Unpin for Share<E, H>
    where <E as Pairing>::G1Affine: Unpin, - <H as HasherDigest>::Bar: Unpin,

    §

    impl<E, H> UnwindSafe for Share<E, H>
    where - <E as Pairing>::ScalarField: UnwindSafe + RefUnwindSafe, + <H as HasherDigest>::Bar: Unpin, + <E as Pairing>::ScalarField: Unpin,

    §

    impl<E, H> UnwindSafe for Share<E, H>
    where <E as Pairing>::G1Affine: UnwindSafe, - <H as HasherDigest>::Bar: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where + <H as HasherDigest>::Bar: UnwindSafe + RefUnwindSafe, + <E as Pairing>::ScalarField: UnwindSafe + RefUnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for T
    where T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for T
    where T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for T
    where T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    §

    impl<T> Downcast for T
    where diff --git a/jf_vid/advz/trait.MaybeGPU.html b/jf_vid/advz/trait.MaybeGPU.html index 943ad1e51..6bfb01290 100644 --- a/jf_vid/advz/trait.MaybeGPU.html +++ b/jf_vid/advz/trait.MaybeGPU.html @@ -1,4 +1,4 @@ -MaybeGPU in jf_vid::advz - Rust

    Trait jf_vid::advz::MaybeGPU

    source · 
    pub trait MaybeGPU<E: Pairing> {
+MaybeGPU in jf_vid::advz - Rust
    Trait jf_vid::advz::MaybeGPU
    source · 
    pub trait MaybeGPU<E: Pairing> {
     // Required method
     fn kzg_batch_commit(
         &mut self,
@@ -6,7 +6,7 @@
     ) -> VidResult<Vec<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Commitment>>;
 }
    Expand description
    A helper trait that cover API that maybe instantiated using GPU code
 in specialized implementation for concrete types
    
-
    Required Methods§
    source
    fn kzg_batch_commit(
+

    Required Methods§

    source

    fn kzg_batch_commit( &mut self, polys: &[DensePolynomial<E::ScalarField>], ) -> VidResult<Vec<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Commitment>>

    kzg batch commit @@ -15,5 +15,5 @@ This should be fixed once ICICLE improve their HostOrDeviceSlice, and we can update our GPUCommittable::commit_on_gpu() input type. depends on https://github.com/ingonyama-zk/icicle/pull/412

    -

    Implementors§

    source§

    impl<E, H> MaybeGPU<E> for Advz<E, H>
    where +

    Implementors§

    source§

    impl<E, H> MaybeGPU<E> for Advz<E, H>
    where E: Pairing,

    \ No newline at end of file diff --git a/jf_vid/advz/type.Advz.html b/jf_vid/advz/type.Advz.html index 9a034e83b..136d4549e 100644 --- a/jf_vid/advz/type.Advz.html +++ b/jf_vid/advz/type.Advz.html @@ -1,6 +1,6 @@ -Advz in jf_vid::advz - Rust

    Type Alias jf_vid::advz::Advz

    source · 
    pub type Advz<E, H> = AdvzInternal<E, H, ()>;
    Expand description

    Normal Advz VID that’s only using CPU

    -

    Aliased Type§

    struct Advz<E, H> { /* private fields */ }

    Implementations§

    source§

    impl<E, H> Advz<E, H>
    where - E: Pairing,

    source

    pub fn new( +Advz in jf_vid::advz - Rust

    Type Alias jf_vid::advz::Advz

    source · 
    pub type Advz<E, H> = AdvzInternal<E, H, ()>;
    Expand description

    Normal Advz VID that’s only using CPU

    +

    Aliased Type§

    struct Advz<E, H> { /* private fields */ }

    Implementations§

    source§

    impl<E, H> Advz<E, H>
    where + E: Pairing,

    source

    pub fn new( num_storage_nodes: u32, recovery_threshold: u32, srs: impl Borrow<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::SRS>, @@ -21,7 +21,7 @@

    §Errors
  • num_storage_nodes < recovery_threshold
  • TEMPORARY recovery_threshold is not a power of two github issue
    • -
    source

    pub fn with_multiplicity( +

    source

    pub fn with_multiplicity( num_storage_nodes: u32, recovery_threshold: u32, max_multiplicity: u32, @@ -36,8 +36,8 @@

    §Errors
    • TEMPORARY max_multiplicity is not a power of two github issue
    -

    Trait Implementations§

    source§

    impl<E, H> MaybeGPU<E> for Advz<E, H>
    where - E: Pairing,

    source§

    fn kzg_batch_commit( +

    Trait Implementations§

    source§

    impl<E, H> MaybeGPU<E> for Advz<E, H>
    where + E: Pairing,

    source§

    fn kzg_batch_commit( &mut self, polys: &[DensePolynomial<E::ScalarField>], ) -> VidResult<Vec<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Commitment>>

    kzg batch commit diff --git a/jf_vid/trait.VidScheme.html b/jf_vid/trait.VidScheme.html index 4bc0a93c7..056c9feff 100644 --- a/jf_vid/trait.VidScheme.html +++ b/jf_vid/trait.VidScheme.html @@ -60,7 +60,7 @@
    source

    fn get_payload_byte_len(common: &Self::Common) -> u32

    Extract the payload byte length data from a VidScheme::Common.

    source

    fn get_num_storage_nodes(common: &Self::Common) -> u32

    Extract the number of storage nodes from a VidScheme::Common.

    source

    fn get_multiplicity(common: &Self::Common) -> u32

    Extract the number of poly evals per share VidScheme::Common.

    -

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where +

    Object Safety§

    This trait is not object safe.

    Implementors§

    source§

    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where E: Pairing, H: HasherDigest, T: Sync, diff --git a/search-index.js b/search-index.js index 7333eeec9..abbc42b72 100644 --- a/search-index.js +++ b/search-index.js @@ -12,7 +12,7 @@ var searchIndex = new Map(JSON.parse('[\ ["jf_signature",{"t":"KTRPRRGKRPRMMNNCNNNNNNNMMMMNNNNMNSSSSSSSSCSSSSSSS","n":["AggregateableSignatureSchemes","CS_ID","MessageUnit","ParameterError","PublicParameter","Signature","SignatureError","SignatureScheme","SigningKey","VerificationError","VerificationKey","aggregate","aggregate_verify","borrow","borrow_mut","constants","eq","equivalent","fmt","fmt","from","from","into","key_gen","multi_sig_verify","param_gen","sign","to_string","try_from","try_into","type_id","verify","vzip","BLS_SIG_COMPRESSED_PK_SIZE","BLS_SIG_COMPRESSED_SIGNATURE_SIZE","BLS_SIG_PK_SIZE","BLS_SIG_SIGNATURE_SIZE","BLS_SIG_SK_SIZE","CS_ID_BLS_BN254","CS_ID_BLS_MIN_SIG","CS_ID_SCHNORR","tag","BLS_SIG","BLS_SIGNING_KEY","BLS_VER_KEY","SCHNORR_KEY_PAIR","SCHNORR_SIG","SCHNORR_SIGNING_KEY","SCHNORR_VER_KEY"],"q":[[0,"jf_signature"],[33,"jf_signature::constants"],[42,"jf_signature::constants::tag"],[49,"core::result"],[50,"core::convert"],[51,"core::fmt"],[52,"blst"],[53,"rand_core"],[54,"core::option"],[55,"alloc::string"],[56,"core::any"]],"i":[0,18,18,3,18,18,0,0,18,3,18,19,19,3,3,0,3,3,3,3,3,3,3,18,19,18,18,3,3,3,3,18,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"f":"```````````{{{b{c}}{b{{d{e}}}}{b{{d{g}}}}}{{h{gf}}}{}{}{}}{{{b{c}}{b{{d{e}}}}{b{{d{i}}}}{b{k}}}{{h{jf}}}{}{}{}{{l{{d{g}}}}}{}}{{{b{c}}}{{b{e}}}{}{}}{{{b{nc}}}{{b{ne}}}{}{}}`{{{b{f}}{b{f}}}A`}{{{b{c}}{b{e}}}A`{}{}}{{{b{f}}{b{nAb}}}Ad}0{cc{}}{Aff}{ce{}{}}{{{b{c}}{b{ne}}}{{h{{Ah{gi}}f}}}{}{AjAl}{}{}}{{{b{c}}{b{{d{e}}}}{b{{d{g}}}}{b{i}}}{{h{jf}}}{}{}{}{}}{{{An{{b{nc}}}}}{{h{ef}}}{AjAl}{}}{{{b{c}}{b{e}}i{b{nk}}}{{h{mf}}}{}{}{}{{l{{d{g}}}}}{AjAl}{}}{{{b{c}}}B`{}}{c{{h{e}}}{}{}}0{{{b{c}}}Bb{}}{{{b{c}}{b{e}}i{b{k}}}{{h{jf}}}{}{}{}{{l{{d{g}}}}}{}}8````````````````","D":"Dl","p":[[1,"reference"],[1,"slice"],[6,"SignatureError",0],[6,"Result",49],[1,"unit"],[10,"AsRef",50],[0,"mut"],[1,"bool"],[5,"Formatter",51],[8,"Result",51],[6,"BLST_ERROR",52],[1,"tuple"],[10,"CryptoRng",53],[10,"RngCore",53],[6,"Option",54],[5,"String",55],[5,"TypeId",56],[10,"SignatureScheme",0],[10,"AggregateableSignatureSchemes",0]],"r":[],"b":[[18,"impl-Debug-for-SignatureError"],[19,"impl-Display-for-SignatureError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAsABQAOAAEAEQADABYAAAAcAAMAIQAAAA=="}],\ ["jf_utils",{"t":"FNNHHCHHNNNQQNHHHHHHNNHHNNHHCCNHQQQQNNNNHHHHFNNNNNNNNNNNHHHNNNNN","n":["CanonicalBytes","borrow","borrow_mut","bytes_from_field_elements","bytes_to_field_elements","canonical","challenge_bit_len","compute_len_to_next_multiple","deref","deref_mut","deserialize","deserialize_canonical_bytes","deserialize_canonical_bytes","drop","field_bit_len","field_byte_len","field_switching","fq_to_fr","fq_to_fr_with_mask","fr_to_fq","from","from","hadamard_product","hash_to_field","init","into","multi_pairing","pad_with_zeros","par_utils","reed_solomon_code","serialize","test_rng","test_serde_default","test_serde_default","to_bytes","to_bytes","try_from","try_into","type_id","vzip","deserialize","serialize","parallelizable_chunks","parallelizable_slice_iter","RSCodeError","as_error_source","borrow","borrow_mut","deref","deref_mut","drop","fmt","fmt","from","init","into","reed_solomon_erasure_decode","reed_solomon_erasure_decode_rou","reed_solomon_erasure_encode","to_string","try_from","try_into","type_id","vzip"],"q":[[0,"jf_utils"],[40,"jf_utils::canonical"],[42,"jf_utils::par_utils"],[44,"jf_utils::reed_solomon_code"],[64,"alloc::vec"],[65,"ark_ff::fields"],[66,"core::borrow"],[67,"jf_utils::serialize"],[68,"core::result"],[69,"serde::de"],[70,"ark_ff::fields::prime"],[71,"ark_serialize"],[72,"alloc::string"],[73,"core::convert"],[74,"ark_ec::pairing"],[75,"serde::ser"],[76,"rand::rngs::std"],[77,"core::any"],[78,"core::slice::iter"],[79,"core::error"],[80,"core::fmt"],[81,"core::iter::traits::collect"],[82,"ark_poly::domain::radix2"],[83,"ark_ff::fields::fft_friendly"],[84,"core::iter::traits::iterator"],[85,"jf_utils::conversion"],[86,"jf_utils::multi_pairing"],[87,"jf_utils::serialize::canonical"]],"i":[0,9,9,0,0,0,0,0,9,9,9,0,0,9,0,0,0,0,0,0,9,9,0,0,9,9,0,0,0,0,9,0,0,0,0,0,9,9,9,9,0,0,0,0,0,26,26,26,26,26,26,26,26,26,26,26,0,0,0,26,26,26,26,26],"f":"`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{e{{h{f}}}j{{n{{l{c}}}}}}{c{{h{e}}}{{n{{l{f}}}}}j}`{{}A`}{{A`A`}A`}{A`{{b{c}}}{}}{A`{{b{dc}}}{}}{c{{Ad{Ab}}}Af}``{A`Ah}55{{{b{c}}}eAjAj}{{{b{c}}}{}Aj}1{bcAj}{cAbAl}{cc{}}{{ei}{{Ad{{h{g}}An}}}{}{{B`{{l{c}}}}}{}{{B`{{l{g}}}}}}{ce{{B`{{l{f}}}}}Aj}<{ce{}{}}{{{b{l}}{b{l}}}{{Bb{c}}}Bd}{{{b{d{h{c}}}}A`}Ahj}``{{{b{Ab}}c}AdBf}{{}Bh}````{c{{Ad{e}}}{}{}}0{{{b{c}}}Bj{}}6{c{{Ad{e}}}AfBl}{{{b{c}}e}AdAlBf}{{{b{{l{c}}}}A`}{{Bn{c}}}{}}{{{b{{l{c}}}}}{{C`{c}}}{}}`{{{b{c}}}{{b{Cb}}}{}}{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{A`{{b{c}}}{}}{A`{{b{dc}}}{}}{A`Ah}{{{b{Cd}}{b{dCf}}}Ch}0{cc{}}{{}A`}{ce{}{}}{{cA`}{{Ad{{h{e}}Cd}}}Cjj}{{cA`{b{{Cl{e}}}}}{{Ad{{h{e}}Cd}}}CjCn}{{cA`}{{`{{Db{}{{D`{e}}}}}}}Cjj}{{{b{c}}}An{}}{c{{Ad{e}}}{}{}}0{{{b{c}}}Bj{}}6","D":"Bn","p":[[1,"reference"],[0,"mut"],[1,"u8"],[5,"Vec",64],[10,"Field",65],[1,"slice"],[10,"Borrow",66],[1,"usize"],[5,"CanonicalBytes",0,67],[6,"Result",68],[10,"Deserializer",69],[1,"unit"],[10,"PrimeField",70],[10,"CanonicalSerialize",71],[5,"String",72],[10,"AsRef",73],[5,"PairingOutput",74],[10,"Pairing",74],[10,"Serializer",75],[5,"StdRng",76],[5,"TypeId",77],[10,"CanonicalDeserialize",71],[5,"Chunks",78],[5,"Iter",78],[10,"Error",79],[5,"RSCodeError",44],[5,"Formatter",80],[8,"Result",80],[10,"IntoIterator",81],[5,"Radix2EvaluationDomain",82],[10,"FftField",83],[17,"Item"],[10,"Iterator",84]],"r":[[0,67],[3,85],[4,85],[5,67],[16,85],[17,85],[18,85],[19,85],[23,85],[26,86],[40,87],[41,87]],"b":[[51,"impl-Debug-for-RSCodeError"],[52,"impl-Display-for-RSCodeError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAACkACgACAAEABwAKABUAAAAZAAAAHAAAAB8AAwAlAAcALgAHADcAAAA8AAQA"}],\ ["jf_vdf",{"t":"RRRRKFNNNNNNNNMNNNNNCMNNNNMNTFFKFNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Input","Output","Proof","PublicParameter","VDF","VDFError","borrow","borrow_mut","deref","deref_mut","drop","eq","equivalent","equivalent","eval","fmt","fmt","from","init","into","minroot","setup","to_string","try_from","try_into","type_id","verify","vzip","EXP_COEF","MinRoot","MinRootElement","MinRootField","MinRootPP","batch_check","batch_check","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","check","check","clone","clone","clone_into","clone_into","cmp","cmp","default","default","deref","deref","deref","deref_mut","deref_mut","deref_mut","deserialize_with_mode","deserialize_with_mode","difficulty","drop","drop","drop","eq","eq","equivalent","equivalent","equivalent","equivalent","eval","fmt","fmt","from","from","from","from","init","init","init","into","into","into","partial_cmp","partial_cmp","serialize_with_mode","serialize_with_mode","serialized_size","serialized_size","setup","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","verify","vzip","vzip","vzip"],"q":[[0,"jf_vdf"],[28,"jf_vdf::minroot"],[104,"core::result"],[105,"core::fmt"],[106,"core::option"],[107,"rand_core"],[108,"alloc::string"],[109,"core::any"],[110,"ark_serialize::error"],[111,"core::iter::traits::iterator"],[112,"core::marker"],[113,"core::clone"],[114,"core::cmp"],[115,"core::default"],[116,"ark_serialize"],[117,"std::io"],[118,"ark_ec"]],"i":[37,37,37,37,0,0,5,5,5,5,5,5,5,5,37,5,5,5,5,5,0,37,5,5,5,5,37,5,22,0,0,0,0,19,23,38,19,23,38,19,23,19,23,19,23,19,23,19,23,19,23,38,19,23,38,19,23,19,23,19,38,19,23,19,23,19,19,23,23,38,19,23,38,19,23,23,38,19,23,38,19,23,19,23,19,23,19,23,38,19,23,38,19,23,38,19,23,38,19,23,38,38,19,23],"f":"``````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{f{{b{c}}}{}}{f{{b{dc}}}{}}{fh}{{{b{j}}{b{j}}}l}{{{b{c}}{b{e}}}l{}{}}0{{{b{c}}{b{e}}}{{A`{{n{gi}}j}}}{}{}{}{}}{{{b{j}}{b{dAb}}}Ad}0{cc{}}{{}f}{ce{}{}}`{{Af{Ah{{b{dc}}}}}{{A`{ej}}}{AjAl}{}}{{{b{c}}}An{}}{c{{A`{e}}}{}{}}0{{{b{c}}}B`{}}{{{b{c}}{b{e}}{b{g}}{b{i}}}{{A`{{A`{hh}}j}}}{}{}{}{}}5`````{c{{A`{hBb}}}{{Bh{}{{Bd{{b{Bf}}}}}}Bj}}{e{{A`{hBb}}}Bl{{Bh{}{{Bd{{b{{Bn{c}}}}}}}}Bj}}{{{b{c}}}{{b{e}}}{}{}}00{{{b{dc}}}{{b{de}}}{}{}}00{{{b{Bf}}}{{A`{hBb}}}}{{{b{{Bn{c}}}}}{{A`{hBb}}}Bl}{{{b{Bf}}}Bf}{{{b{{Bn{c}}}}}{{Bn{c}}}{C`Bl}}{{{b{c}}{b{de}}}h{}{}}0{{{b{Bf}}{b{Bf}}}Cb}{{{b{{Bn{c}}}}{b{{Bn{c}}}}}Cb{CdBl}}{{}Bf}{{}{{Bn{c}}}{CfBl}}{f{{b{c}}}{}}00{f{{b{dc}}}{}}00{{cChCj}{{A`{BfBb}}}Cl}{{cChCj}{{A`{{Bn{e}}Bb}}}ClBl}`{fh}00{{{b{Bf}}{b{Bf}}}l}{{{b{{Bn{c}}}}{b{{Bn{c}}}}}l{CnBl}}{{{b{c}}{b{e}}}l{}{}}000{{{b{c}}{b{e}}}{{A`{{n{gi}}j}}}{}{}{}{}}{{{b{Bf}}{b{dAb}}}Ad}{{{b{{Bn{c}}}}{b{dAb}}}Ad{D`Bl}}{cc{}}00{e{{Bn{c}}}Bl{{Dd{}{{Db{c}}}}}}{{}f}00{ce{}{}}00{{{b{Bf}}{b{Bf}}}{{Ah{Cb}}}}{{{b{{Bn{c}}}}{b{{Bn{c}}}}}{{Ah{Cb}}}{DfBl}}{{{b{Bf}}cCh}{{A`{hBb}}}Dh}{{{b{{Bn{c}}}}eCh}{{A`{hBb}}}BlDh}{{{b{Bf}}Ch}f}{{{b{{Bn{c}}}}Ch}fBl}{{Af{Ah{{b{dc}}}}}{{A`{ej}}}{AjAl}{}}{{{b{c}}}e{}{}}0{c{{A`{e}}}{}{}}00000{{{b{c}}}B`{}}00{{{b{c}}{b{e}}{b{g}}{b{i}}}{{A`{{A`{hh}}j}}}{}{}{}{}};;;","D":"Cb","p":[[1,"reference"],[0,"mut"],[1,"usize"],[1,"unit"],[5,"VDFError",0],[1,"bool"],[1,"tuple"],[6,"Result",104],[5,"Formatter",105],[8,"Result",105],[1,"u64"],[6,"Option",106],[10,"CryptoRng",107],[10,"RngCore",107],[5,"String",108],[5,"TypeId",109],[6,"SerializationError",110],[17,"Item"],[5,"MinRootPP",28],[10,"Iterator",111],[10,"Send",112],[10,"MinRootField",28],[5,"MinRootElement",28],[10,"Clone",113],[6,"Ordering",114],[10,"Ord",114],[10,"Default",115],[6,"Compress",116],[6,"Validate",116],[10,"Read",117],[10,"PartialEq",114],[10,"Debug",105],[17,"BaseField"],[10,"AffineRepr",118],[10,"PartialOrd",114],[10,"Write",117],[10,"VDF",0],[5,"MinRoot",28]],"r":[],"b":[[15,"impl-Debug-for-VDFError"],[16,"impl-Display-for-VDFError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAE8ACQAHAAcAEAABABMAAAAXAAMAHAAAACIAGQA9AAsATAADAFMAFQA="}],\ -["jf_vid",{"t":"PRRPPPRFGIKNCNNNNNNNNNNNOMONNNNNMNNNNNNNNNNNMMMNNNNNNNNNNNMCCMNONNNNNNNNMNNIFFKFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNCNNCNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFNNNNNNNOONNNNNNNNNMOMONNNNNKRMM","n":["Argument","Commit","Common","Err","Internal","Ok","Share","VidDisperse","VidError","VidResult","VidScheme","__clone_box","advz","as_any","as_any","as_any_mut","as_any_mut","as_error_source","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","commit","commit_only","common","deref","deref","deref_mut","deref_mut","deserialize","disperse","drop","drop","eq","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","get_multiplicity","get_num_storage_nodes","get_payload_byte_len","hash","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_consistent","payload_prover","precomputable","recover_payload","serialize","shares","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","verify_share","vzip","vzip","Advz","AdvzInternal","Common","MaybeGPU","Share","__clone_box","__clone_box","__clone_box","as_any","as_any","as_any","as_any_mut","as_any_mut","as_any_mut","batch_check","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","check","clone","clone","clone","clone_into","clone_into","clone_into","commit_only","commit_only_precompute","deref","deref","deref","deref_mut","deref_mut","deref_mut","deserialize","deserialize","deserialize_with_mode","disperse","disperse_precompute","drop","drop","drop","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","from","get_multiplicity","get_num_storage_nodes","get_payload_byte_len","hash","hash","init","init","init","into","into","into","into_any","into_any","into_any","into_any_arc","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_any_rc","is_consistent","kzg_batch_commit","kzg_batch_commit","new","new","payload_proof","payload_proof","payload_prover","payload_verify","payload_verify","precomputable","recover_payload","serialize","serialize","serialize_with_mode","serialized_size","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","verify_share","vzip","vzip","vzip","with_multiplicity","with_multiplicity","LargeRangeProof","SmallRangeProof","__clone_box","__clone_box","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","deref","deref","deref_mut","deref_mut","deserialize","deserialize","drop","drop","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","from","from","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","serialize","serialize","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","PrecomputeData","__clone_box","as_any","as_any_mut","batch_check","borrow","borrow_mut","check","clone","clone_into","deref","deref_mut","deserialize","deserialize_with_mode","drop","eq","equivalent","equivalent","equivalent","fmt","from","hash","init","into","into_any","into_any_arc","into_any_rc","serialize","serialize_with_mode","serialized_size","to_owned","try_from","try_into","type_id","vzip","PayloadProver","Statement","__clone_box","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","commit","common","deref","deref_mut","drop","from","init","into","into_any","into_any_arc","into_any_rc","payload_proof","payload_subslice","payload_verify","range","to_owned","try_from","try_into","type_id","vzip","Precomputable","PrecomputeData","commit_only_precompute","disperse_precompute"],"q":[[0,"jf_vid"],[75,"jf_vid::advz"],[191,"jf_vid::advz::payload_prover"],[249,"jf_vid::advz::precomputable"],[284,"jf_vid::payload_prover"],[313,"jf_vid::precomputable"],[317,"dyn_clone::sealed"],[318,"core::any"],[319,"core::error"],[320,"core::marker"],[321,"core::clone"],[322,"core::fmt"],[323,"serde::de"],[324,"core::cmp"],[325,"core::hash"],[326,"serde::ser"],[327,"tagged_base64"],[328,"core::convert"],[329,"core::result"],[330,"alloc::boxed"],[331,"alloc::sync"],[332,"alloc::rc"],[333,"alloc::vec"],[334,"alloc::string"],[335,"ark_serialize::error"],[336,"ark_ec::pairing"],[337,"jf_merkle_tree::hasher"],[338,"core::iter::traits::iterator"],[339,"ark_serialize"],[340,"std::io"],[341,"ark_poly::polynomial::univariate::dense"],[342,"core::borrow"],[343,"core::ops::range"]],"i":[35,8,8,13,35,13,8,0,0,0,0,7,0,7,35,7,35,35,7,35,7,35,7,7,7,8,7,7,35,7,35,7,8,7,35,7,7,7,7,7,35,35,7,35,8,8,8,7,7,35,7,35,7,35,7,35,7,35,8,0,0,8,7,7,7,35,7,35,7,35,7,35,8,7,35,0,0,0,0,0,52,53,49,52,53,49,52,53,49,49,52,53,49,52,53,49,49,52,53,49,52,53,49,52,52,52,53,49,52,53,49,53,49,49,52,52,52,53,49,52,53,49,52,52,52,53,53,53,49,49,49,52,53,49,52,53,49,52,52,52,53,49,52,53,49,52,53,49,52,53,49,52,53,49,52,53,49,52,58,60,60,52,52,52,0,52,52,0,52,53,49,49,49,52,53,49,52,53,49,52,53,49,52,53,49,52,52,53,49,60,52,0,0,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,64,64,63,63,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,0,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,0,0,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,70,65,70,65,65,65,65,65,65,0,72,72,72],"f":"```````````{{{b{c}}d}f{}}`{{{b{c}}}{{b{h}}}{}}0{{{b{jc}}}{{b{jh}}}{}}0{{{b{c}}}{{b{l}}}{}}{{{b{c}}}{{b{e}}}{}{}}0{{{b{jc}}}{{b{je}}}{}{}}0{{{b{{n{c}}}}}{{n{c}}}{A`Ab}}{{{b{c}}{b{je}}}f{}{}}`{{{b{j{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}i}{{Aj{c}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}{{Ch{{Cf{Cd}}}}}}`{Cj{{b{c}}}{}}0{Cj{{b{jc}}}{}}0{c{{Cl{{n{e}}}}}Cn{A`Ab}}{{{b{j{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}i}{{Aj{{n{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}{{Ch{{Cf{Cd}}}}}}{Cjf}0{{{b{{n{c}}}}{b{{n{c}}}}}D`{A`Ab}}{{{b{c}}{b{e}}}D`{}{}}00{{{b{{n{c}}}}{b{jDb}}}Dd{A`Ab}}{{{b{Df}}{b{jDb}}}Dd}0{cc{}}0{{{b{c}}}Dh{}}00{{{b{{n{c}}}}{b{je}}}f{A`Ab}Dj}{{}Cj}0{ce{}{}}0{{{Dl{c}}}{{Dl{h}}}{}}0{{{Dn{c}}}{{Dn{h}}}{}}0{{{E`{c}}}{{E`{h}}}{}}0{{{b{c}}{b{e}}}{{Aj{f}}}{}{}}``{{{b{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}{b{{Cf{e}}}}{b{g}}}{{Aj{{Eb{Cd}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}}{{{b{{n{c}}}}e}Cl{A`Ab}Ed}`{{{b{c}}}e{}{}}{{{b{c}}}Ef{}}{c{{Cl{e}}}{}{}}000{{{b{c}}}Eh{}}0{{{b{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}{b{e}}{b{g}}{b{c}}}{{Aj{{Cl{ff}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}};;`````{{{b{c}}d}f{}}00{{{b{c}}}{{b{h}}}{}}00{{{b{jc}}}{{b{jh}}}{}}00{g{{Cl{fEj}}}ElEn{{Fd{}{{F`{{b{{Fb{ce}}}}}}}}Ff}}{{{b{c}}}{{b{e}}}{}{}}00{{{b{jc}}}{{b{je}}}{}{}}00{{{b{{Fb{ce}}}}}{{Cl{fEj}}}ElEn}{{{b{{Fh{ceg}}}}}{{Fh{ceg}}}{ElAl}Al{BlAl}}{{{b{{Fj{ce}}}}}{{Fj{ce}}}ElEn}{{{b{{Fb{ce}}}}}{{Fb{ce}}}ElEn}{{{b{c}}{b{je}}}f{}{}}00{{{b{j{Fh{ceg}}}}i}{{Aj{k}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}}{{{b{{Fh{ceg}}}}i}{{Aj{{Fl{km}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}{}}{Cj{{b{c}}}{}}00{Cj{{b{jc}}}{}}00{c{{Cl{{Fj{eg}}}}}CnElEn}{c{{Cl{{Fb{eg}}}}}CnElEn}{{cFnG`}{{Cl{{Fb{eg}}Ej}}}GbElEn}{{{b{j{Fh{ceg}}}}i}{{Aj{{n{{Fh{ceg}}}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}}{{{b{{Fh{ceg}}}}i{b{k}}}{{Aj{{n{{Fh{ceg}}}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}}{Cjf}00{{{b{{Fh{ceg}}}}{b{{Fh{ceg}}}}}D`{ElBf}Bf{BlBf}}{{{b{{Fj{ce}}}}{b{{Fj{ce}}}}}D`ElEn}{{{b{{Fb{ce}}}}{b{{Fb{ce}}}}}D`ElEn}{{{b{c}}{b{e}}}D`{}{}}00000000{{{b{{Fh{ceg}}}}{b{jDb}}}Dd{ElAn}An{BlAn}}{{{b{{Fj{ce}}}}{b{jDb}}}DdElEn}{{{b{{Fb{ce}}}}{b{jDb}}}DdElEn}{cc{}}00{{{b{c}}}Dh{}}00{{{b{{Fj{ce}}}}{b{jg}}}fElEnDj}{{{b{{Fb{ce}}}}{b{jg}}}fElEnDj}{{}Cj}00{ce{}{}}00{{{Dl{c}}}{{Dl{h}}}{}}00{{{Dn{c}}}{{Dn{h}}}{}}00{{{E`{c}}}{{E`{h}}}{}}00{{{b{c}}{b{e}}}{{Aj{f}}}{}{}}{{{b{jGd}}{b{{Cf{Gf}}}}}{{Aj{Eb}}}}{{{b{j{Gh{ce}}}}{b{{Cf{Gf}}}}}{{Aj{Eb}}}El{}}{{DhDhc}{{Aj{{Gh{eg}}}}}GjEl{}}{{DhDhc}{{Aj{{Fh{egf}}}}}GjEl{}}{{{b{{Fh{ceg}}}}i{Gl{Cj}}}{{Aj{Gn}}}ElEnBl{{Ch{{Cf{Cd}}}}}}{{{b{{Fh{ceg}}}}i{Gl{Cj}}}{{Aj{H`}}}ElEnBl{{Ch{{Cf{Cd}}}}}}`{{{b{{Fh{ceg}}}}{Hb{{Fh{ceg}}}}{b{Gn}}}{{Aj{{Cl{ff}}}}}ElEnBl}{{{b{{Fh{ceg}}}}{Hb{{Fh{ceg}}}}{b{H`}}}{{Aj{{Cl{ff}}}}}ElEnBl}`{{{b{{Fh{ceg}}}}{b{{Cf{i}}}}{b{k}}}{{Aj{{Eb{Cd}}}}}ElEnBl{}{}}{{{b{{Fj{ce}}}}g}ClElEnEd}{{{b{{Fb{ce}}}}g}ClElEnEd}{{{b{{Fb{ce}}}}gFn}{{Cl{fEj}}}ElEnHd}{{{b{{Fb{ce}}}}Fn}CjElEn}{{{b{c}}}e{}{}}00{c{{Cl{e}}}{}{}}00000{{{b{c}}}Eh{}}00{{{b{{Fh{ceg}}}}{b{i}}{b{k}}{b{m}}}{{Aj{{Cl{ff}}}}}ElEnBl{}{}{}}{ce{}{}}00{{DhDhDhc}{{Aj{{Gh{eg}}}}}GjEl{}}{{DhDhDhc}{{Aj{{Fh{egf}}}}}GjEl{}}``{{{b{c}}d}f{}}0{{{b{c}}}{{b{h}}}{}}0{{{b{jc}}}{{b{jh}}}{}}0{{{b{c}}}{{b{e}}}{}{}}0{{{b{jc}}}{{b{je}}}{}{}}0{{{b{{H`{c}}}}}{{H`{c}}}Al}{{{b{{Gn{c}}}}}{{Gn{c}}}Al}{{{b{c}}{b{je}}}f{}{}}0{Cj{{b{c}}}{}}0{Cj{{b{jc}}}{}}0{c{{Cl{{H`{e}}}}}Cn{HfHh}}{c{{Cl{{Gn{e}}}}}Cn{HfHh}}{Cjf}0{{{b{{H`{c}}}}{b{{H`{c}}}}}D`Bf}{{{b{{Gn{c}}}}{b{{Gn{c}}}}}D`Bf}{{{b{c}}{b{e}}}D`{}{}}00000{{{b{{H`{c}}}}{b{jDb}}}DdAn}{{{b{{Gn{c}}}}{b{jDb}}}DdAn}{cc{}}0{{}Cj}0{ce{}{}}0{{{Dl{c}}}{{Dl{h}}}{}}0{{{Dn{c}}}{{Dn{h}}}{}}0{{{E`{c}}}{{E`{h}}}{}}0{{{b{{H`{c}}}}e}Cl{HfHh}Ed}{{{b{{Gn{c}}}}e}Cl{HfHh}Ed}{{{b{c}}}e{}{}}0{c{{Cl{e}}}{}{}}000{{{b{c}}}Eh{}}088`{{{b{c}}d}f{}}{{{b{c}}}{{b{h}}}{}}{{{b{jc}}}{{b{jh}}}{}}{e{{Cl{fEj}}}El{{Fd{}{{F`{{b{{Hj{c}}}}}}}}Ff}}{{{b{c}}}{{b{e}}}{}{}}{{{b{jc}}}{{b{je}}}{}{}}{{{b{{Hj{c}}}}}{{Cl{fEj}}}El}{{{b{{Hj{c}}}}}{{Hj{c}}}{ElAl}}{{{b{c}}{b{je}}}f{}{}}{Cj{{b{c}}}{}}{Cj{{b{jc}}}{}}{c{{Cl{{Hj{e}}}}}CnEl}{{cFnG`}{{Cl{{Hj{e}}Ej}}}GbEl}{Cjf}{{{b{{Hj{c}}}}{b{{Hj{c}}}}}D`{ElBf}}{{{b{c}}{b{e}}}D`{}{}}00{{{b{{Hj{c}}}}{b{jDb}}}Dd{ElAn}}{cc{}}{{{b{{Hj{c}}}}{b{je}}}fElDj}{{}Cj}{ce{}{}}{{{Dl{c}}}{{Dl{h}}}{}}{{{Dn{c}}}{{Dn{h}}}{}}{{{E`{c}}}{{E`{h}}}{}}{{{b{{Hj{c}}}}e}ClElEd}{{{b{{Hj{c}}}}eFn}{{Cl{fEj}}}ElHd}{{{b{{Hj{c}}}}Fn}CjEl}{{{b{c}}}e{}{}}{c{{Cl{e}}}{}{}}0{{{b{c}}}Eh{}}9``{{{b{c}}d}f{}}{{{b{c}}}{{b{h}}}{}}{{{b{jc}}}{{b{jh}}}{}}{{{b{c}}}{{b{e}}}{}{}}{{{b{jc}}}{{b{je}}}{}{}}{{{b{{Hb{c}}}}}{{Hb{c}}}A`}{{{b{c}}{b{je}}}f{}{}}``{Cj{{b{c}}}{}}{Cj{{b{jc}}}{}}{Cjf}{cc{}}{{}Cj}{ce{}{}}{{{Dl{c}}}{{Dl{h}}}{}}{{{Dn{c}}}{{Dn{h}}}{}}{{{E`{c}}}{{E`{h}}}{}}{{{b{Hl}}c{Gl{Cj}}}{{Aj{e}}}{{Ch{{Cf{Cd}}}}}{AlAnBdBfBjBb}}`{{{b{Hl}}{Hb{Hl}}{b{c}}}{{Aj{{Cl{ff}}}}}{AlAnBdBfBjBb}}`{{{b{c}}}e{}{}}{c{{Cl{e}}}{}{}}0{{{b{c}}}Eh{}}8``{{{b{{I`{}{{Hn{c}}}}}}e}{{Aj{{Fl{gc}}}}}{AlAnBdBfBhBlBjBb}{{Ch{{Cf{Cd}}}}}{}}{{{b{{I`{}{{Hn{c}}}}}}e{b{c}}}{{Aj{{n{{I`{}{{Hn{c}}}}}}}}}{AlAnBdBfBhBlBjBb}{{Ch{{Cf{Cd}}}}}}","D":"Hn","p":[[1,"reference"],[5,"Private",317],[1,"unit"],[10,"Any",318],[0,"mut"],[10,"Error",319],[5,"VidDisperse",0],[10,"VidScheme",0],[10,"Sized",320],[17,"Commit"],[17,"Share"],[17,"Common"],[8,"VidResult",0],[10,"Clone",321],[10,"Debug",322],[10,"Display",322],[10,"DeserializeOwned",323],[10,"Eq",324],[10,"PartialEq",324],[10,"Hash",325],[10,"Serialize",326],[10,"Sync",320],[5,"TaggedBase64",327],[10,"TryFrom",328],[10,"Into",328],[1,"u8"],[1,"slice"],[10,"AsRef",328],[1,"usize"],[6,"Result",329],[10,"Deserializer",323],[1,"bool"],[5,"Formatter",322],[8,"Result",322],[6,"VidError",0],[1,"u32"],[10,"Hasher",325],[5,"Box",330],[5,"Arc",331],[5,"Rc",332],[5,"Vec",333],[10,"Serializer",326],[5,"String",334],[5,"TypeId",318],[6,"SerializationError",335],[10,"Pairing",336],[10,"HasherDigest",337],[17,"Item"],[5,"Common",75],[10,"Iterator",338],[10,"Send",320],[5,"AdvzInternal",75],[5,"Share",75],[1,"tuple"],[6,"Compress",339],[6,"Validate",339],[10,"Read",340],[10,"MaybeGPU",75],[5,"DensePolynomial",341],[8,"Advz",75],[10,"Borrow",342],[5,"Range",343],[5,"LargeRangeProof",191],[5,"SmallRangeProof",191],[5,"Statement",284],[10,"Write",340],[10,"CanonicalSerialize",339],[10,"CanonicalDeserialize",339],[5,"PrecomputeData",249],[10,"PayloadProver",284],[17,"PrecomputeData"],[10,"Precomputable",313]],"r":[],"b":[[40,"impl-Display-for-VidError"],[41,"impl-Debug-for-VidError"],[162,"impl-PayloadProver%3CLargeRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Evaluation%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[163,"impl-PayloadProver%3CSmallRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Proof%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[165,"impl-PayloadProver%3CLargeRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Evaluation%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[166,"impl-PayloadProver%3CSmallRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Proof%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAPYAGwAMAAAADgAKABwABAAiAAgAMAACADUABQA/AAAAQQAHAEoAAQBRADUAigAHAJUACQCgAAAAowABAKYAAQCpABQAwgAfAOQAAQDoABEA+wASAA8BAQASAQoAHwEGACgBAgAsAQAALgECADUBBAA="}],\ +["jf_vid",{"t":"PRRPPPRFGIKNCNNNNNNNNNNNOMONNNNNMNNNNNNNNNNNMMMNNNNNNNNNNNMCCMNONNNNNNNNMNNIFFKFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNCNNCNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFNNNNNNNOONNNNNNNNNMOMONNNNNKRMM","n":["Argument","Commit","Common","Err","Internal","Ok","Share","VidDisperse","VidError","VidResult","VidScheme","__clone_box","advz","as_any","as_any","as_any_mut","as_any_mut","as_error_source","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","commit","commit_only","common","deref","deref","deref_mut","deref_mut","deserialize","disperse","drop","drop","eq","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","get_multiplicity","get_num_storage_nodes","get_payload_byte_len","hash","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_consistent","payload_prover","precomputable","recover_payload","serialize","shares","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","verify_share","vzip","vzip","Advz","AdvzInternal","Common","MaybeGPU","Share","__clone_box","__clone_box","__clone_box","as_any","as_any","as_any","as_any_mut","as_any_mut","as_any_mut","batch_check","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","check","clone","clone","clone","clone_into","clone_into","clone_into","commit_only","commit_only_precompute","deref","deref","deref","deref_mut","deref_mut","deref_mut","deserialize","deserialize","deserialize_with_mode","disperse","disperse_precompute","drop","drop","drop","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","from","get_multiplicity","get_num_storage_nodes","get_payload_byte_len","hash","hash","init","init","init","into","into","into","into_any","into_any","into_any","into_any_arc","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_any_rc","is_consistent","kzg_batch_commit","kzg_batch_commit","new","new","payload_proof","payload_proof","payload_prover","payload_verify","payload_verify","precomputable","recover_payload","serialize","serialize","serialize_with_mode","serialized_size","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","verify_share","vzip","vzip","vzip","with_multiplicity","with_multiplicity","LargeRangeProof","SmallRangeProof","__clone_box","__clone_box","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","deref","deref","deref_mut","deref_mut","deserialize","deserialize","drop","drop","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","from","from","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","serialize","serialize","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","PrecomputeData","__clone_box","as_any","as_any_mut","batch_check","borrow","borrow_mut","check","clone","clone_into","deref","deref_mut","deserialize","deserialize_with_mode","drop","eq","equivalent","equivalent","equivalent","fmt","from","hash","init","into","into_any","into_any_arc","into_any_rc","serialize","serialize_with_mode","serialized_size","to_owned","try_from","try_into","type_id","vzip","PayloadProver","Statement","__clone_box","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","commit","common","deref","deref_mut","drop","from","init","into","into_any","into_any_arc","into_any_rc","payload_proof","payload_subslice","payload_verify","range","to_owned","try_from","try_into","type_id","vzip","Precomputable","PrecomputeData","commit_only_precompute","disperse_precompute"],"q":[[0,"jf_vid"],[75,"jf_vid::advz"],[191,"jf_vid::advz::payload_prover"],[249,"jf_vid::advz::precomputable"],[284,"jf_vid::payload_prover"],[313,"jf_vid::precomputable"],[317,"dyn_clone::sealed"],[318,"core::any"],[319,"core::error"],[320,"core::marker"],[321,"core::clone"],[322,"core::fmt"],[323,"serde::de"],[324,"core::cmp"],[325,"core::hash"],[326,"serde::ser"],[327,"tagged_base64"],[328,"core::convert"],[329,"core::result"],[330,"alloc::boxed"],[331,"alloc::sync"],[332,"alloc::rc"],[333,"alloc::vec"],[334,"alloc::string"],[335,"ark_serialize::error"],[336,"ark_ec::pairing"],[337,"jf_merkle_tree::hasher"],[338,"core::iter::traits::iterator"],[339,"ark_serialize"],[340,"std::io"],[341,"ark_poly::polynomial::univariate::dense"],[342,"core::borrow"],[343,"core::ops::range"]],"i":[35,8,8,13,35,13,8,0,0,0,0,7,0,7,35,7,35,35,7,35,7,35,7,7,7,8,7,7,35,7,35,7,8,7,35,7,7,7,7,7,35,35,7,35,8,8,8,7,7,35,7,35,7,35,7,35,7,35,8,0,0,8,7,7,7,35,7,35,7,35,7,35,8,7,35,0,0,0,0,0,52,53,49,52,53,49,52,53,49,49,52,53,49,52,53,49,49,52,53,49,52,53,49,52,52,52,53,49,52,53,49,53,49,49,52,52,52,53,49,52,53,49,52,52,52,53,53,53,49,49,49,52,53,49,52,53,49,52,52,52,53,49,52,53,49,52,53,49,52,53,49,52,53,49,52,53,49,52,58,60,60,52,52,52,0,52,52,0,52,53,49,49,49,52,53,49,52,53,49,52,53,49,52,53,49,52,52,53,49,60,52,0,0,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,64,64,63,63,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,64,63,0,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,0,0,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,70,65,70,65,65,65,65,65,65,0,72,72,72],"f":"```````````{{{b{c}}d}f{}}`{{{b{c}}}{{b{h}}}{}}0{{{b{jc}}}{{b{jh}}}{}}0{{{b{c}}}{{b{l}}}{}}{{{b{c}}}{{b{e}}}{}{}}0{{{b{jc}}}{{b{je}}}{}{}}0{{{b{{n{c}}}}}{{n{c}}}{A`Ab}}{{{b{c}}{b{je}}}f{}{}}`{{{b{j{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}i}{{Aj{c}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}{{Ch{{Cf{Cd}}}}}}`{Cj{{b{c}}}{}}0{Cj{{b{jc}}}{}}0{c{{Cl{{n{e}}}}}Cn{A`Ab}}{{{b{j{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}i}{{Aj{{n{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}{{Ch{{Cf{Cd}}}}}}{Cjf}0{{{b{{n{c}}}}{b{{n{c}}}}}D`{A`Ab}}{{{b{c}}{b{e}}}D`{}{}}00{{{b{{n{c}}}}{b{jDb}}}Dd{A`Ab}}{{{b{Df}}{b{jDb}}}Dd}0{cc{}}0{{{b{c}}}Dh{}}00{{{b{{n{c}}}}{b{je}}}f{A`Ab}Dj}{{}Cj}0{ce{}{}}0{{{Dl{c}}}{{Dl{h}}}{}}0{{{Dn{c}}}{{Dn{h}}}{}}0{{{E`{c}}}{{E`{h}}}{}}0{{{b{c}}{b{e}}}{{Aj{f}}}{}{}}``{{{b{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}{b{{Cf{e}}}}{b{g}}}{{Aj{{Eb{Cd}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}}{{{b{{n{c}}}}e}Cl{A`Ab}Ed}`{{{b{c}}}e{}{}}{{{b{c}}}Ef{}}{c{{Cl{e}}}{}{}}000{{{b{c}}}Eh{}}0{{{b{{A`{}{{Ad{c}}{Af{e}}{Ah{g}}}}}}{b{e}}{b{g}}{b{c}}}{{Aj{{Cl{ff}}}}}{AlAnB`BbBdBfBhBjBl{C`{{b{Bn}}}}{Cb{Bn}}}{AlAnBbBdBfBhBjBl}{AlAnBbBdBfBhBjBl}};;`````{{{b{c}}d}f{}}00{{{b{c}}}{{b{h}}}{}}00{{{b{jc}}}{{b{jh}}}{}}00{g{{Cl{fEj}}}ElEn{{Fd{}{{F`{{b{{Fb{ce}}}}}}}}Ff}}{{{b{c}}}{{b{e}}}{}{}}00{{{b{jc}}}{{b{je}}}{}{}}00{{{b{{Fb{ce}}}}}{{Cl{fEj}}}ElEn}{{{b{{Fh{ceg}}}}}{{Fh{ceg}}}{ElAl}Al{BlAl}}{{{b{{Fj{ce}}}}}{{Fj{ce}}}ElEn}{{{b{{Fb{ce}}}}}{{Fb{ce}}}ElEn}{{{b{c}}{b{je}}}f{}{}}00{{{b{j{Fh{ceg}}}}i}{{Aj{k}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}}{{{b{{Fh{ceg}}}}i}{{Aj{{Fl{km}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}{}}{Cj{{b{c}}}{}}00{Cj{{b{jc}}}{}}00{c{{Cl{{Fj{eg}}}}}CnElEn}{c{{Cl{{Fb{eg}}}}}CnElEn}{{cFnG`}{{Cl{{Fb{eg}}Ej}}}GbElEn}{{{b{j{Fh{ceg}}}}i}{{Aj{{n{{Fh{ceg}}}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}}{{{b{{Fh{ceg}}}}i{b{k}}}{{Aj{{n{{Fh{ceg}}}}}}}ElEnBl{{Ch{{Cf{Cd}}}}}{}}{Cjf}00{{{b{{Fh{ceg}}}}{b{{Fh{ceg}}}}}D`{ElBf}Bf{BlBf}}{{{b{{Fj{ce}}}}{b{{Fj{ce}}}}}D`ElEn}{{{b{{Fb{ce}}}}{b{{Fb{ce}}}}}D`ElEn}{{{b{c}}{b{e}}}D`{}{}}00000000{{{b{{Fh{ceg}}}}{b{jDb}}}Dd{ElAn}An{BlAn}}{{{b{{Fj{ce}}}}{b{jDb}}}DdElEn}{{{b{{Fb{ce}}}}{b{jDb}}}DdElEn}{cc{}}00{{{b{c}}}Dh{}}00{{{b{{Fj{ce}}}}{b{jg}}}fElEnDj}{{{b{{Fb{ce}}}}{b{jg}}}fElEnDj}{{}Cj}00{ce{}{}}00{{{Dl{c}}}{{Dl{h}}}{}}00{{{Dn{c}}}{{Dn{h}}}{}}00{{{E`{c}}}{{E`{h}}}{}}00{{{b{c}}{b{e}}}{{Aj{f}}}{}{}}{{{b{jGd}}{b{{Cf{Gf}}}}}{{Aj{Eb}}}}{{{b{j{Gh{ce}}}}{b{{Cf{Gf}}}}}{{Aj{Eb}}}El{}}{{DhDhc}{{Aj{{Gh{eg}}}}}GjEl{}}{{DhDhc}{{Aj{{Fh{egf}}}}}GjEl{}}{{{b{{Fh{ceg}}}}i{Gl{Cj}}}{{Aj{Gn}}}ElEnBl{{Ch{{Cf{Cd}}}}}}{{{b{{Fh{ceg}}}}i{Gl{Cj}}}{{Aj{H`}}}ElEnBl{{Ch{{Cf{Cd}}}}}}`{{{b{{Fh{ceg}}}}{Hb{{Fh{ceg}}}}{b{Gn}}}{{Aj{{Cl{ff}}}}}ElEnBl}{{{b{{Fh{ceg}}}}{Hb{{Fh{ceg}}}}{b{H`}}}{{Aj{{Cl{ff}}}}}ElEnBl}`{{{b{{Fh{ceg}}}}{b{{Cf{i}}}}{b{k}}}{{Aj{{Eb{Cd}}}}}ElEnBl{}{}}{{{b{{Fj{ce}}}}g}ClElEnEd}{{{b{{Fb{ce}}}}g}ClElEnEd}{{{b{{Fb{ce}}}}gFn}{{Cl{fEj}}}ElEnHd}{{{b{{Fb{ce}}}}Fn}CjElEn}{{{b{c}}}e{}{}}00{c{{Cl{e}}}{}{}}00000{{{b{c}}}Eh{}}00{{{b{{Fh{ceg}}}}{b{i}}{b{k}}{b{m}}}{{Aj{{Cl{ff}}}}}ElEnBl{}{}{}}{ce{}{}}00{{DhDhDhc}{{Aj{{Gh{eg}}}}}GjEl{}}{{DhDhDhc}{{Aj{{Fh{egf}}}}}GjEl{}}``{{{b{c}}d}f{}}0{{{b{c}}}{{b{h}}}{}}0{{{b{jc}}}{{b{jh}}}{}}0{{{b{c}}}{{b{e}}}{}{}}0{{{b{jc}}}{{b{je}}}{}{}}0{{{b{{H`{c}}}}}{{H`{c}}}Al}{{{b{{Gn{c}}}}}{{Gn{c}}}Al}{{{b{c}}{b{je}}}f{}{}}0{Cj{{b{c}}}{}}0{Cj{{b{jc}}}{}}0{c{{Cl{{H`{e}}}}}Cn{HfHh}}{c{{Cl{{Gn{e}}}}}Cn{HfHh}}{Cjf}0{{{b{{H`{c}}}}{b{{H`{c}}}}}D`Bf}{{{b{{Gn{c}}}}{b{{Gn{c}}}}}D`Bf}{{{b{c}}{b{e}}}D`{}{}}00000{{{b{{H`{c}}}}{b{jDb}}}DdAn}{{{b{{Gn{c}}}}{b{jDb}}}DdAn}{cc{}}0{{}Cj}0{ce{}{}}0{{{Dl{c}}}{{Dl{h}}}{}}0{{{Dn{c}}}{{Dn{h}}}{}}0{{{E`{c}}}{{E`{h}}}{}}0{{{b{{H`{c}}}}e}Cl{HfHh}Ed}{{{b{{Gn{c}}}}e}Cl{HfHh}Ed}{{{b{c}}}e{}{}}0{c{{Cl{e}}}{}{}}000{{{b{c}}}Eh{}}088`{{{b{c}}d}f{}}{{{b{c}}}{{b{h}}}{}}{{{b{jc}}}{{b{jh}}}{}}{e{{Cl{fEj}}}El{{Fd{}{{F`{{b{{Hj{c}}}}}}}}Ff}}{{{b{c}}}{{b{e}}}{}{}}{{{b{jc}}}{{b{je}}}{}{}}{{{b{{Hj{c}}}}}{{Cl{fEj}}}El}{{{b{{Hj{c}}}}}{{Hj{c}}}{ElAl}}{{{b{c}}{b{je}}}f{}{}}{Cj{{b{c}}}{}}{Cj{{b{jc}}}{}}{c{{Cl{{Hj{e}}}}}CnEl}{{cFnG`}{{Cl{{Hj{e}}Ej}}}GbEl}{Cjf}{{{b{{Hj{c}}}}{b{{Hj{c}}}}}D`{ElBf}}{{{b{c}}{b{e}}}D`{}{}}00{{{b{{Hj{c}}}}{b{jDb}}}Dd{ElAn}}{cc{}}{{{b{{Hj{c}}}}{b{je}}}fElDj}{{}Cj}{ce{}{}}{{{Dl{c}}}{{Dl{h}}}{}}{{{Dn{c}}}{{Dn{h}}}{}}{{{E`{c}}}{{E`{h}}}{}}{{{b{{Hj{c}}}}e}ClElEd}{{{b{{Hj{c}}}}eFn}{{Cl{fEj}}}ElHd}{{{b{{Hj{c}}}}Fn}CjEl}{{{b{c}}}e{}{}}{c{{Cl{e}}}{}{}}0{{{b{c}}}Eh{}}9``{{{b{c}}d}f{}}{{{b{c}}}{{b{h}}}{}}{{{b{jc}}}{{b{jh}}}{}}{{{b{c}}}{{b{e}}}{}{}}{{{b{jc}}}{{b{je}}}{}{}}{{{b{{Hb{c}}}}}{{Hb{c}}}A`}{{{b{c}}{b{je}}}f{}{}}``{Cj{{b{c}}}{}}{Cj{{b{jc}}}{}}{Cjf}{cc{}}{{}Cj}{ce{}{}}{{{Dl{c}}}{{Dl{h}}}{}}{{{Dn{c}}}{{Dn{h}}}{}}{{{E`{c}}}{{E`{h}}}{}}{{{b{Hl}}c{Gl{Cj}}}{{Aj{e}}}{{Ch{{Cf{Cd}}}}}{AlAnBdBfBjBb}}`{{{b{Hl}}{Hb{Hl}}{b{c}}}{{Aj{{Cl{ff}}}}}{AlAnBdBfBjBb}}`{{{b{c}}}e{}{}}{c{{Cl{e}}}{}{}}0{{{b{c}}}Eh{}}8``{{{b{{I`{}{{Hn{c}}}}}}e}{{Aj{{Fl{gc}}}}}{AlAnBdBfBhBlBjBb}{{Ch{{Cf{Cd}}}}}{}}{{{b{{I`{}{{Hn{c}}}}}}e{b{c}}}{{Aj{{n{{I`{}{{Hn{c}}}}}}}}}{AlAnBdBfBhBlBjBb}{{Ch{{Cf{Cd}}}}}}","D":"Hn","p":[[1,"reference"],[5,"Private",317],[1,"unit"],[10,"Any",318],[0,"mut"],[10,"Error",319],[5,"VidDisperse",0],[10,"VidScheme",0],[10,"Sized",320],[17,"Commit"],[17,"Share"],[17,"Common"],[8,"VidResult",0],[10,"Clone",321],[10,"Debug",322],[10,"Display",322],[10,"DeserializeOwned",323],[10,"Eq",324],[10,"PartialEq",324],[10,"Hash",325],[10,"Serialize",326],[10,"Sync",320],[5,"TaggedBase64",327],[10,"TryFrom",328],[10,"Into",328],[1,"u8"],[1,"slice"],[10,"AsRef",328],[1,"usize"],[6,"Result",329],[10,"Deserializer",323],[1,"bool"],[5,"Formatter",322],[8,"Result",322],[6,"VidError",0],[1,"u32"],[10,"Hasher",325],[5,"Box",330],[5,"Arc",331],[5,"Rc",332],[5,"Vec",333],[10,"Serializer",326],[5,"String",334],[5,"TypeId",318],[6,"SerializationError",335],[10,"Pairing",336],[10,"HasherDigest",337],[17,"Item"],[5,"Common",75],[10,"Iterator",338],[10,"Send",320],[5,"AdvzInternal",75],[5,"Share",75],[1,"tuple"],[6,"Compress",339],[6,"Validate",339],[10,"Read",340],[10,"MaybeGPU",75],[5,"DensePolynomial",341],[8,"Advz",75],[10,"Borrow",342],[5,"Range",343],[5,"LargeRangeProof",191],[5,"SmallRangeProof",191],[5,"Statement",284],[10,"Write",340],[10,"CanonicalSerialize",339],[10,"CanonicalDeserialize",339],[5,"PrecomputeData",249],[10,"PayloadProver",284],[17,"PrecomputeData"],[10,"Precomputable",313]],"r":[],"b":[[40,"impl-Debug-for-VidError"],[41,"impl-Display-for-VidError"],[162,"impl-PayloadProver%3CLargeRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Evaluation%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[163,"impl-PayloadProver%3CSmallRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Proof%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[165,"impl-PayloadProver%3CLargeRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Evaluation%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"],[166,"impl-PayloadProver%3CSmallRangeProof%3C%3CUnivariateKzgPCS%3CE%3E+as+PolynomialCommitmentScheme%3E::Proof%3E%3E-for-AdvzInternal%3CE,+H,+T%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAPYAGwAMAAAADgAKABwABAAiAAgAMAACADUABQA/AAAAQQAHAEoAAQBRADUAigAHAJUACQCgAAAAowABAKYAAQCpABQAwgAfAOQAAQDoABEA+wASAA8BAQASAQoAHwEGACgBAgAsAQAALgECADUBBAA="}],\ ["jf_vrf",{"t":"RRRRRRRKCNMMMMMGFFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Error","Input","Output","Proof","PublicKey","PublicParameter","SecretKey","Vrf","blsvrf","evaluate","key_gen","param_gen","proof_to_hash","prove","verify","BLSVRFCipherSuite","BLSVRFError","BLSVRFScheme","VRF_BLS_12_381_SHA256","VRF_BLS_12_381_SHA512","as_error_source","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","fmt","fmt","fmt","from","from","from","init","init","init","into","into","into","key_gen","new","param_gen","proof_to_hash","prove","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","verify","vzip","vzip","vzip"],"q":[[0,"jf_vrf"],[15,"jf_vrf::blsvrf"],[67,"core::result"],[68,"core::fmt"],[69,"core::clone"],[70,"core::marker"],[71,"serde::de"],[72,"serde::ser"],[73,"core::cmp"],[74,"zeroize"],[75,"core::error"],[76,"rand_core"],[77,"core::option"],[78,"alloc::string"],[79,"core::any"]],"i":[9,9,9,9,9,9,9,0,0,9,9,9,9,9,9,0,0,0,29,29,32,33,29,32,33,29,32,33,29,32,33,29,32,33,29,32,29,32,32,33,29,32,33,29,32,33,29,32,33,33,33,33,33,32,33,29,32,33,29,32,33,29,32,33,33,29,32],"f":"`````````{{{Ad{b{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Ad{c}}{Ad{g}}{Ad{k}}{Ad{bAa}}}{{Af{mo}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj{BlBn}}{{{Ad{{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Ad{c}}{Ad{bAa}}}{{Af{{C`{ge}}o}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj{BlBn}}{{{Ad{{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Cb{{Ad{bAa}}}}}{{Af{co}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj{BlBn}}{{{Ad{b{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Ad{c}}{Ad{i}}}{{Af{mo}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj}{{{Ad{{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Ad{c}}{Ad{g}}{Ad{k}}{Ad{bAa}}}{{Af{io}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj{BlBn}}{{{Ad{b{Ab{}{{d{c}}{f{e}}{h{g}}{j{i}}{l{k}}{n{m}}{A`{o}}}}}}{Ad{c}}{Ad{i}}{Ad{e}}{Ad{k}}}{{Af{{C`{Cd{Cb{m}}}}o}}}{}{AhAjAlAnB`BbBdBf}{AhAjAlAnBhB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}{AhAjAlAnB`BbBdBf}Bj}`````{{{Ad{c}}}{{Ad{Bj}}}{}}{{{Ad{c}}}{{Ad{e}}}{}{}}00{{{Ad{bc}}}{{Ad{be}}}{}{}}00{Cf{{Ad{c}}}{}}00{Cf{{Ad{bc}}}{}}00{CfCh}00{{{Ad{Cj}}{Ad{bCl}}}Cn}{{{Ad{D`}}{Ad{bCl}}}Cn}0{cc{}}00{{}Cf}00{ce{}{}}00{{{Ad{Db}}{Ad{c}}{Ad{be}}}{{Af{{C`{gi}}D`}}}{}{BlBn}{}{}}{CjDb}{{{Ad{Db}}{Cb{{Ad{bc}}}}}{{Af{eD`}}}{BlBn}{}}{{{Ad{bDb}}{Ad{c}}{Ad{e}}}{{Af{gD`}}}{}{}{}}{{{Ad{Db}}{Ad{c}}{Ad{e}}{Ad{g}}{Ad{bi}}}{{Af{kD`}}}{}{}{}{BlBn}{}}{{{Ad{c}}}Dd{}}{c{{Af{e}}}{}{}}00000{{{Ad{c}}}Df{}}00{{{Ad{bDb}}{Ad{c}}{Ad{e}}{Ad{g}}{Ad{i}}}{{Af{{C`{Cd{Cb{k}}}}D`}}}{}{}{}{}{}}999","D":"Db","p":[[0,"mut"],[17,"PublicParameter"],[17,"PublicKey"],[17,"SecretKey"],[17,"Proof"],[17,"Input"],[17,"Output"],[17,"Error"],[10,"Vrf",0],[1,"reference"],[6,"Result",67],[10,"Debug",68],[10,"Clone",69],[10,"Send",70],[10,"Sync",70],[10,"Deserialize",71],[10,"Serialize",72],[10,"PartialEq",73],[10,"Eq",73],[10,"Zeroize",74],[10,"Error",75],[10,"CryptoRng",76],[10,"RngCore",76],[1,"tuple"],[6,"Option",77],[1,"bool"],[1,"usize"],[1,"unit"],[6,"BLSVRFCipherSuite",15],[5,"Formatter",68],[8,"Result",68],[5,"BLSVRFError",15],[5,"BLSVRFScheme",15],[5,"String",78],[5,"TypeId",79]],"r":[],"b":[[37,"impl-Display-for-BLSVRFError"],[38,"impl-Debug-for-BLSVRFError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAACIABAAVABIAKwACADYACQBBAAIA"}]\ ]')); if (typeof exports !== 'undefined') exports.searchIndex = searchIndex; diff --git a/settings.html b/settings.html index 8bfa22452..e9c4105aa 100644 --- a/settings.html +++ b/settings.html @@ -1 +1 @@ -Settings

    Rustdoc settings

    Back
    \ No newline at end of file +Settings

    Rustdoc settings

    Back
    \ No newline at end of file diff --git a/src/jf_vid/advz.rs.html b/src/jf_vid/advz.rs.html index 00385f4ae..9d0ea648d 100644 --- a/src/jf_vid/advz.rs.html +++ b/src/jf_vid/advz.rs.html @@ -1039,6 +1039,39 @@ 1039 1040 1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 
    // Copyright (c) 2022 Espresso Systems (espressosys.com)
 // This file is part of the Jellyfish library.
 
@@ -1076,6 +1109,7 @@
 use itertools::Itertools;
 use jf_merkle_tree::{
     hasher::{HasherDigest, HasherMerkleTree, HasherNode},
+    prelude::{MerkleNode, MerkleProof},
     MerkleCommitment, MerkleTreeScheme,
 };
 #[cfg(feature = "gpu-vid")]
@@ -1330,15 +1364,41 @@
 {
     index: u32,
 
-    #[serde(with = "canonical")]
-    evals: Vec<KzgEval<E>>,
-
     #[serde(with = "canonical")]
     // aggregate_proofs.len() equals multiplicity
     // TODO further aggregate into a single KZG proof.
     aggregate_proofs: Vec<KzgProof<E>>,
 
-    eval_proofs: Vec<KzgEvalsMerkleTreeProof<E, H>>,
+    // eval_proofs.len() equals multiplicity
+    // TODO put all evals into a single merkle proof
+    // https://github.com/EspressoSystems/jellyfish/issues/671
+    eval_proofs: Vec<KzgEvalsMerkleTreeProof<E, H>>,
+}
+
+impl<E, H> Share<E, H>
+where
+    E: Pairing,
+    H: HasherDigest,
+{
+    /// Return a [`Vec`] of payload data for this share.
+    ///
+    /// These data are extracted from [`MerkleProof`] structs. The returned
+    /// [`Vec`] has length `multiplicity * num_polys`s
+    ///
+    /// TODO store these data in a new field `Share::evals` after fixing
+    /// https://github.com/EspressoSystems/jellyfish/issues/658
+    fn evals(&self) -> VidResult<Vec<KzgEval<E>>> {
+        self.eval_proofs
+            .iter()
+            .map(|eval_proof| {
+                eval_proof
+                    .elem()
+                    .cloned()
+                    .ok_or_else(|| VidError::Internal(anyhow::anyhow!("empty merkle proof")))
+            })
+            .flatten_ok()
+            .collect()
+    }
 }
 
 /// The [`VidScheme::Common`] type for [`Advz`].
@@ -1476,10 +1536,11 @@
                 common.multiplicity, multiplicity
             )));
         }
-        if share.evals.len() / multiplicity as usize != common.poly_commits.len() {
+        let evals = share.evals()?;
+        if evals.len() / multiplicity as usize != common.poly_commits.len() {
             return Err(VidError::Argument(format!(
                 "number of share evals / multiplicity {}/{} differs from number of common polynomial commitments {}",
-                share.evals.len(), multiplicity,
+                evals.len(), multiplicity,
                 common.poly_commits.len()
             )));
         }
@@ -1538,14 +1599,13 @@
         let verification_iter = parallelizable_slice_iter(&multiplicities).map(|i| {
             let range = i * polys_len..(i + 1) * polys_len;
             let aggregate_eval = polynomial_eval(
-                share
-                    .evals
+                evals
                     .get(range.clone())
                     .ok_or_else(|| {
                         VidError::Internal(anyhow::anyhow!(
                             "share evals range {:?} out of bounds for length {}",
                             range,
-                            share.evals.len()
+                            evals.len()
                         ))
                     })?
                     .iter()
@@ -1594,23 +1654,27 @@
             )));
         }
 
+        let shares_evals = shares
+            .iter()
+            .map(|share| share.evals())
+            .collect::<VidResult<Vec<_>>>()?;
+
         // check args: all shares must have equal evals len
-        let num_evals = shares
+        let num_evals = shares_evals
             .first()
             .ok_or_else(|| VidError::Argument("shares is empty".into()))?
-            .evals
-            .len();
-        if let Some((index, share)) = shares
+            .len();
+        if let Some((index, share_evals)) = shares_evals
             .iter()
             .enumerate()
-            .find(|(_, s)| s.evals.len() != num_evals)
+            .find(|(_, evals)| evals.len() != num_evals)
         {
             return Err(VidError::Argument(format!(
                 "shares do not have equal evals lengths: share {} len {}, share {} len {}",
                 0,
                 num_evals,
                 index,
-                share.evals.len()
+                share_evals.len()
             )));
         }
         if num_evals != common.multiplicity as usize * common.poly_commits.len() {
@@ -1631,12 +1695,12 @@
         let mut elems = Vec::with_capacity(elems_capacity);
         let mut evals = Vec::with_capacity(num_evals);
         for p in 0..num_polys {
-            for share in shares {
+            for (share, share_evals) in shares.iter().zip(shares_evals.iter()) {
                 // extract all evaluations for polynomial p from the share
                 for m in 0..common.multiplicity as usize {
                     evals.push((
                         (share.index * common.multiplicity) as usize + m,
-                        share.evals[(m * num_polys) + p],
+                        share_evals[(m * num_polys) + p],
                     ))
                 }
             }
@@ -1718,7 +1782,6 @@
             multiplicity * self.recovery_threshold
         ));
         let all_storage_node_evals = {
-            let mut all_storage_node_evals = vec![Vec::with_capacity(polys.len()); code_word_size];
             let all_poly_evals = parallelizable_slice_iter(&polys)
                 .map(|poly| {
                     UnivariateKzgPCS::<E>::multi_open_rou_evals(
@@ -1730,6 +1793,10 @@
                 })
                 .collect::<Result<Vec<_>, VidError>>()?;
 
+            // distribute evals from each poly among the storage nodes
+            //
+            // perf warning: runtime is quadratic in payload_size
+            let mut all_storage_node_evals = vec![Vec::with_capacity(polys.len()); code_word_size];
             for poly_evals in all_poly_evals {
                 for (storage_node_evals, poly_eval) in all_storage_node_evals
                     .iter_mut()
@@ -1817,7 +1884,6 @@
                     let (evals, proofs, eval_proofs): (Vec<_>, _, _) = chunk.multiunzip();
                     Share {
                         index: index as u32,
-                        evals: evals.into_iter().flatten().collect::<Vec<_>>(),
                         aggregate_proofs: proofs,
                         eval_proofs,
                     }
diff --git a/trait.impl/core/marker/trait.Unpin.js b/trait.impl/core/marker/trait.Unpin.js
index 0e782f811..2c161b3bd 100644
--- a/trait.impl/core/marker/trait.Unpin.js
+++ b/trait.impl/core/marker/trait.Unpin.js
@@ -9,6 +9,6 @@
 "jf_signature":[["impl Unpin for SignatureError",1,["jf_signature::SignatureError"]]],
 "jf_utils":[["impl Unpin for RSCodeError",1,["jf_utils::reed_solomon_code::RSCodeError"]],["impl Unpin for CanonicalBytes",1,["jf_utils::serialize::CanonicalBytes"]]],
 "jf_vdf":[["impl Unpin for MinRootPP",1,["jf_vdf::minroot::MinRootPP"]],["impl Unpin for VDFError",1,["jf_vdf::VDFError"]],["impl<F> Unpin for MinRoot<F>
    where\n    F: Unpin,
    ",1,["jf_vdf::minroot::MinRoot"]],["impl<F> Unpin for MinRootElement<F>
    where\n    F: Unpin,
    ",1,["jf_vdf::minroot::MinRootElement"]]],
-"jf_vid":[["impl Unpin for VidError",1,["jf_vid::VidError"]],["impl<'a, V> Unpin for Statement<'a, V>
    where\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> Unpin for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: Unpin,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> Unpin for Common<E, H>
    where\n    <H as HasherDigest>::Bar: Unpin,\n    <E as Pairing>::G1Affine: Unpin,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> Unpin for Share<E, H>
    where\n    <E as Pairing>::ScalarField: Unpin,\n    <E as Pairing>::G1Affine: Unpin,\n    <H as HasherDigest>::Bar: Unpin,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> Unpin for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: Unpin,\n    <E as Pairing>::G2Affine: Unpin,\n    T: Unpin,\n    H: Unpin,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> Unpin for LargeRangeProof<F>
    where\n    F: Unpin,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> Unpin for SmallRangeProof<P>
    where\n    P: Unpin,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> Unpin for VidDisperse<V>
    where\n    <V as VidScheme>::Common: Unpin,\n    <V as VidScheme>::Commit: Unpin,\n    <V as VidScheme>::Share: Unpin,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
+"jf_vid":[["impl Unpin for VidError",1,["jf_vid::VidError"]],["impl<'a, V> Unpin for Statement<'a, V>
    where\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> Unpin for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: Unpin,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> Unpin for Common<E, H>
    where\n    <H as HasherDigest>::Bar: Unpin,\n    <E as Pairing>::G1Affine: Unpin,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> Unpin for Share<E, H>
    where\n    <E as Pairing>::G1Affine: Unpin,\n    <H as HasherDigest>::Bar: Unpin,\n    <E as Pairing>::ScalarField: Unpin,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> Unpin for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: Unpin,\n    <E as Pairing>::G2Affine: Unpin,\n    T: Unpin,\n    H: Unpin,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> Unpin for LargeRangeProof<F>
    where\n    F: Unpin,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> Unpin for SmallRangeProof<P>
    where\n    P: Unpin,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> Unpin for VidDisperse<V>
    where\n    <V as VidScheme>::Common: Unpin,\n    <V as VidScheme>::Commit: Unpin,\n    <V as VidScheme>::Share: Unpin,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
 "jf_vrf":[["impl Unpin for BLSVRFCipherSuite",1,["jf_vrf::blsvrf::BLSVRFCipherSuite"]],["impl Unpin for BLSVRFError",1,["jf_vrf::blsvrf::BLSVRFError"]],["impl Unpin for BLSVRFScheme",1,["jf_vrf::blsvrf::BLSVRFScheme"]]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
index fa2255cf3..5de639e5c 100644
--- a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
+++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
@@ -9,6 +9,6 @@
 "jf_signature":[["impl RefUnwindSafe for SignatureError",1,["jf_signature::SignatureError"]]],
 "jf_utils":[["impl RefUnwindSafe for RSCodeError",1,["jf_utils::reed_solomon_code::RSCodeError"]],["impl RefUnwindSafe for CanonicalBytes",1,["jf_utils::serialize::CanonicalBytes"]]],
 "jf_vdf":[["impl RefUnwindSafe for MinRootPP",1,["jf_vdf::minroot::MinRootPP"]],["impl RefUnwindSafe for VDFError",1,["jf_vdf::VDFError"]],["impl<F> RefUnwindSafe for MinRoot<F>
    where\n    F: RefUnwindSafe,
    ",1,["jf_vdf::minroot::MinRoot"]],["impl<F> RefUnwindSafe for MinRootElement<F>
    where\n    F: RefUnwindSafe,
    ",1,["jf_vdf::minroot::MinRootElement"]]],
-"jf_vid":[["impl RefUnwindSafe for VidError",1,["jf_vid::VidError"]],["impl<'a, V> RefUnwindSafe for Statement<'a, V>
    where\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Common: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> RefUnwindSafe for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: RefUnwindSafe,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> RefUnwindSafe for Common<E, H>
    where\n    <H as HasherDigest>::Bar: RefUnwindSafe,\n    <E as Pairing>::G1Affine: RefUnwindSafe,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> RefUnwindSafe for Share<E, H>
    where\n    <E as Pairing>::ScalarField: RefUnwindSafe,\n    <E as Pairing>::G1Affine: RefUnwindSafe,\n    <H as HasherDigest>::Bar: RefUnwindSafe,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> RefUnwindSafe for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: RefUnwindSafe,\n    <E as Pairing>::G2Affine: RefUnwindSafe,\n    T: RefUnwindSafe,\n    H: RefUnwindSafe,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> RefUnwindSafe for LargeRangeProof<F>
    where\n    F: RefUnwindSafe,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> RefUnwindSafe for SmallRangeProof<P>
    where\n    P: RefUnwindSafe,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> RefUnwindSafe for VidDisperse<V>
    where\n    <V as VidScheme>::Common: RefUnwindSafe,\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Share: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
+"jf_vid":[["impl RefUnwindSafe for VidError",1,["jf_vid::VidError"]],["impl<'a, V> RefUnwindSafe for Statement<'a, V>
    where\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Common: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> RefUnwindSafe for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: RefUnwindSafe,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> RefUnwindSafe for Common<E, H>
    where\n    <H as HasherDigest>::Bar: RefUnwindSafe,\n    <E as Pairing>::G1Affine: RefUnwindSafe,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> RefUnwindSafe for Share<E, H>
    where\n    <E as Pairing>::G1Affine: RefUnwindSafe,\n    <H as HasherDigest>::Bar: RefUnwindSafe,\n    <E as Pairing>::ScalarField: RefUnwindSafe,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> RefUnwindSafe for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: RefUnwindSafe,\n    <E as Pairing>::G2Affine: RefUnwindSafe,\n    T: RefUnwindSafe,\n    H: RefUnwindSafe,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> RefUnwindSafe for LargeRangeProof<F>
    where\n    F: RefUnwindSafe,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> RefUnwindSafe for SmallRangeProof<P>
    where\n    P: RefUnwindSafe,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> RefUnwindSafe for VidDisperse<V>
    where\n    <V as VidScheme>::Common: RefUnwindSafe,\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Share: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
 "jf_vrf":[["impl !RefUnwindSafe for BLSVRFScheme",1,["jf_vrf::blsvrf::BLSVRFScheme"]],["impl RefUnwindSafe for BLSVRFCipherSuite",1,["jf_vrf::blsvrf::BLSVRFCipherSuite"]],["impl RefUnwindSafe for BLSVRFError",1,["jf_vrf::blsvrf::BLSVRFError"]]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
index ec2d0d34a..52e2a63bf 100644
--- a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
+++ b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
@@ -9,6 +9,6 @@
 "jf_signature":[["impl UnwindSafe for SignatureError",1,["jf_signature::SignatureError"]]],
 "jf_utils":[["impl UnwindSafe for RSCodeError",1,["jf_utils::reed_solomon_code::RSCodeError"]],["impl UnwindSafe for CanonicalBytes",1,["jf_utils::serialize::CanonicalBytes"]]],
 "jf_vdf":[["impl UnwindSafe for MinRootPP",1,["jf_vdf::minroot::MinRootPP"]],["impl UnwindSafe for VDFError",1,["jf_vdf::VDFError"]],["impl<F> UnwindSafe for MinRoot<F>
    where\n    F: UnwindSafe,
    ",1,["jf_vdf::minroot::MinRoot"]],["impl<F> UnwindSafe for MinRootElement<F>
    where\n    F: UnwindSafe,
    ",1,["jf_vdf::minroot::MinRootElement"]]],
-"jf_vid":[["impl UnwindSafe for VidError",1,["jf_vid::VidError"]],["impl<'a, V> UnwindSafe for Statement<'a, V>
    where\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Common: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> UnwindSafe for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: UnwindSafe,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> UnwindSafe for Common<E, H>
    where\n    <H as HasherDigest>::Bar: UnwindSafe,\n    <E as Pairing>::G1Affine: UnwindSafe,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> UnwindSafe for Share<E, H>
    where\n    <E as Pairing>::ScalarField: UnwindSafe + RefUnwindSafe,\n    <E as Pairing>::G1Affine: UnwindSafe,\n    <H as HasherDigest>::Bar: UnwindSafe + RefUnwindSafe,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> UnwindSafe for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: UnwindSafe,\n    <E as Pairing>::G2Affine: UnwindSafe,\n    T: UnwindSafe,\n    H: UnwindSafe,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> UnwindSafe for LargeRangeProof<F>
    where\n    F: UnwindSafe,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> UnwindSafe for SmallRangeProof<P>
    where\n    P: UnwindSafe,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> UnwindSafe for VidDisperse<V>
    where\n    <V as VidScheme>::Common: UnwindSafe,\n    <V as VidScheme>::Commit: UnwindSafe,\n    <V as VidScheme>::Share: UnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
+"jf_vid":[["impl UnwindSafe for VidError",1,["jf_vid::VidError"]],["impl<'a, V> UnwindSafe for Statement<'a, V>
    where\n    <V as VidScheme>::Commit: RefUnwindSafe,\n    <V as VidScheme>::Common: RefUnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::payload_prover::Statement"]],["impl<E> UnwindSafe for PrecomputeData<E>
    where\n    <E as Pairing>::G1Affine: UnwindSafe,
    ",1,["jf_vid::advz::precomputable::PrecomputeData"]],["impl<E, H> UnwindSafe for Common<E, H>
    where\n    <H as HasherDigest>::Bar: UnwindSafe,\n    <E as Pairing>::G1Affine: UnwindSafe,
    ",1,["jf_vid::advz::Common"]],["impl<E, H> UnwindSafe for Share<E, H>
    where\n    <E as Pairing>::G1Affine: UnwindSafe,\n    <H as HasherDigest>::Bar: UnwindSafe + RefUnwindSafe,\n    <E as Pairing>::ScalarField: UnwindSafe + RefUnwindSafe,
    ",1,["jf_vid::advz::Share"]],["impl<E, H, T> UnwindSafe for AdvzInternal<E, H, T>
    where\n    <E as Pairing>::G1Affine: UnwindSafe,\n    <E as Pairing>::G2Affine: UnwindSafe,\n    T: UnwindSafe,\n    H: UnwindSafe,
    ",1,["jf_vid::advz::AdvzInternal"]],["impl<F> UnwindSafe for LargeRangeProof<F>
    where\n    F: UnwindSafe,
    ",1,["jf_vid::advz::payload_prover::LargeRangeProof"]],["impl<P> UnwindSafe for SmallRangeProof<P>
    where\n    P: UnwindSafe,
    ",1,["jf_vid::advz::payload_prover::SmallRangeProof"]],["impl<V> UnwindSafe for VidDisperse<V>
    where\n    <V as VidScheme>::Common: UnwindSafe,\n    <V as VidScheme>::Commit: UnwindSafe,\n    <V as VidScheme>::Share: UnwindSafe,\n    V: ?Sized,
    ",1,["jf_vid::VidDisperse"]]],
 "jf_vrf":[["impl !UnwindSafe for BLSVRFScheme",1,["jf_vrf::blsvrf::BLSVRFScheme"]],["impl UnwindSafe for BLSVRFCipherSuite",1,["jf_vrf::blsvrf::BLSVRFCipherSuite"]],["impl UnwindSafe for BLSVRFError",1,["jf_vrf::blsvrf::BLSVRFError"]]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/type.impl/jf_vid/advz/struct.AdvzInternal.js b/type.impl/jf_vid/advz/struct.AdvzInternal.js
index 82813c213..e16c9ed6b 100644
--- a/type.impl/jf_vid/advz/struct.AdvzInternal.js
+++ b/type.impl/jf_vid/advz/struct.AdvzInternal.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"jf_vid":[["
    source§
    impl<E, H: Clone, T> Clone for AdvzInternal<E, H, T>
    where\n    E: Pairing + Clone,\n    T: Sync + Clone,
    source§
    fn clone(&self) -> AdvzInternal<E, H, T>
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    ","Clone","jf_vid::advz::Advz"],["
    source§
    impl<E, H: Debug, T> Debug for AdvzInternal<E, H, T>
    where\n    E: Pairing + Debug,\n    T: Sync + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    ","Debug","jf_vid::advz::Advz"],["
    source§
    impl<E, H: PartialEq, T> PartialEq for AdvzInternal<E, H, T>
    where\n    E: Pairing + PartialEq,\n    T: Sync + PartialEq,
    source§
    fn eq(&self, other: &AdvzInternal<E, H, T>) -> bool
    This method tests for self and other values to be equal, and is used\nby ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
    ","PartialEq","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> PayloadProver<LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>> for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    source§
    fn payload_proof<B>(\n    &self,\n    payload: B,\n    range: Range<usize>,\n) -> VidResult<LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>>
    where\n    B: AsRef<[u8]>,
    Compute a proof for a subslice of payload data. Read more
    source§
    fn payload_verify(\n    &self,\n    stmt: Statement<'_, Self>,\n    proof: &LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>,\n) -> VidResult<Result<(), ()>>
    Verify a proof made by PayloadProver::payload_proof. Read more
    ","PayloadProver as PolynomialCommitmentScheme>::Evaluation>>","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> PayloadProver<SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>> for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    source§
    fn payload_proof<B>(\n    &self,\n    payload: B,\n    range: Range<usize>,\n) -> VidResult<SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>>
    where\n    B: AsRef<[u8]>,
    Compute a proof for a subslice of payload data. Read more
    source§
    fn payload_verify(\n    &self,\n    stmt: Statement<'_, Self>,\n    proof: &SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>,\n) -> VidResult<Result<(), ()>>
    Verify a proof made by PayloadProver::payload_proof. Read more
    ","PayloadProver as PolynomialCommitmentScheme>::Proof>>","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> Precomputable for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    §
    type PrecomputeData = PrecomputeData<E>
    Precomputed data that can be (re-)used during disperse computation
    source§
    fn commit_only_precompute<B>(\n    &self,\n    payload: B,\n) -> VidResult<(Self::Commit, Self::PrecomputeData)>
    where\n    B: AsRef<[u8]>,
    Similar to VidScheme::commit_only but returns additional data that\ncan be used as input to disperse_precompute for faster dispersal.
    source§
    fn disperse_precompute<B>(\n    &self,\n    payload: B,\n    data: &Self::PrecomputeData,\n) -> VidResult<VidDisperse<Self>>
    where\n    B: AsRef<[u8]>,
    Similar to VidScheme::disperse but takes as input additional\ndata for more efficient computation and faster disersal.
    ","Precomputable","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    §
    type Commit = HasherNode<H>
    Payload commitment.
    §
    type Share = Share<E, H>
    Share-specific data sent to a storage node.
    §
    type Common = Common<E, H>
    Common data sent to all storage nodes.
    source§
    fn commit_only<B>(&mut self, payload: B) -> VidResult<Self::Commit>
    where\n    B: AsRef<[u8]>,
    Compute a payload commitment
    source§
    fn disperse<B>(&mut self, payload: B) -> VidResult<VidDisperse<Self>>
    where\n    B: AsRef<[u8]>,
    Compute shares to send to the storage nodes
    source§
    fn verify_share(\n    &self,\n    share: &Self::Share,\n    common: &Self::Common,\n    commit: &Self::Commit,\n) -> VidResult<Result<(), ()>>
    Verify a share. Used by both storage node and retrieval client.\nWhy is return type a nested Result? See https://sled.rs/errors\nReturns: Read more
    source§
    fn recover_payload(\n    &self,\n    shares: &[Self::Share],\n    common: &Self::Common,\n) -> VidResult<Vec<u8>>
    Recover payload from shares.\nDo not verify shares or check recovered payload against anything.
    source§
    fn is_consistent(commit: &Self::Commit, common: &Self::Common) -> VidResult<()>
    Check that a VidScheme::Common is consistent with a\nVidScheme::Commit. Read more
    source§
    fn get_payload_byte_len(common: &Self::Common) -> u32
    Extract the payload byte length data from a VidScheme::Common.
    source§
    fn get_num_storage_nodes(common: &Self::Common) -> u32
    Extract the number of storage nodes from a VidScheme::Common.
    source§
    fn get_multiplicity(common: &Self::Common) -> u32
    Extract the number of poly evals per share VidScheme::Common.
    ","VidScheme","jf_vid::advz::Advz"],["
    source§
    impl<E, H: Eq, T> Eq for AdvzInternal<E, H, T>
    where\n    E: Pairing + Eq,\n    T: Sync + Eq,
    ","Eq","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> StructuralPartialEq for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    T: Sync,
    ","StructuralPartialEq","jf_vid::advz::Advz"]]
+"jf_vid":[["
    source§
    impl<E, H: Clone, T> Clone for AdvzInternal<E, H, T>
    where\n    E: Pairing + Clone,\n    T: Sync + Clone,
    source§
    fn clone(&self) -> AdvzInternal<E, H, T>
    Returns a copy of the value. Read more
    1.0.0 · source§
    fn clone_from(&mut self, source: &Self)
    Performs copy-assignment from source. Read more
    ","Clone","jf_vid::advz::Advz"],["
    source§
    impl<E, H: Debug, T> Debug for AdvzInternal<E, H, T>
    where\n    E: Pairing + Debug,\n    T: Sync + Debug,
    source§
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
    Formats the value using the given formatter. Read more
    ","Debug","jf_vid::advz::Advz"],["
    source§
    impl<E, H: PartialEq, T> PartialEq for AdvzInternal<E, H, T>
    where\n    E: Pairing + PartialEq,\n    T: Sync + PartialEq,
    source§
    fn eq(&self, other: &AdvzInternal<E, H, T>) -> bool
    This method tests for self and other values to be equal, and is used\nby ==.
    1.0.0 · source§
    fn ne(&self, other: &Rhs) -> bool
    This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
    ","PartialEq","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> PayloadProver<LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>> for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    source§
    fn payload_proof<B>(\n    &self,\n    payload: B,\n    range: Range<usize>,\n) -> VidResult<LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>>
    where\n    B: AsRef<[u8]>,
    Compute a proof for a subslice of payload data. Read more
    source§
    fn payload_verify(\n    &self,\n    stmt: Statement<'_, Self>,\n    proof: &LargeRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Evaluation>,\n) -> VidResult<Result<(), ()>>
    Verify a proof made by PayloadProver::payload_proof. Read more
    ","PayloadProver as PolynomialCommitmentScheme>::Evaluation>>","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> PayloadProver<SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>> for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    source§
    fn payload_proof<B>(\n    &self,\n    payload: B,\n    range: Range<usize>,\n) -> VidResult<SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>>
    where\n    B: AsRef<[u8]>,
    Compute a proof for a subslice of payload data. Read more
    source§
    fn payload_verify(\n    &self,\n    stmt: Statement<'_, Self>,\n    proof: &SmallRangeProof<<UnivariateKzgPCS<E> as PolynomialCommitmentScheme>::Proof>,\n) -> VidResult<Result<(), ()>>
    Verify a proof made by PayloadProver::payload_proof. Read more
    ","PayloadProver as PolynomialCommitmentScheme>::Proof>>","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> Precomputable for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    §
    type PrecomputeData = PrecomputeData<E>
    Precomputed data that can be (re-)used during disperse computation
    source§
    fn commit_only_precompute<B>(\n    &self,\n    payload: B,\n) -> VidResult<(Self::Commit, Self::PrecomputeData)>
    where\n    B: AsRef<[u8]>,
    Similar to VidScheme::commit_only but returns additional data that\ncan be used as input to disperse_precompute for faster dispersal.
    source§
    fn disperse_precompute<B>(\n    &self,\n    payload: B,\n    data: &Self::PrecomputeData,\n) -> VidResult<VidDisperse<Self>>
    where\n    B: AsRef<[u8]>,
    Similar to VidScheme::disperse but takes as input additional\ndata for more efficient computation and faster disersal.
    ","Precomputable","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> VidScheme for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    H: HasherDigest,\n    T: Sync,\n    AdvzInternal<E, H, T>: MaybeGPU<E>,
    §
    type Commit = HasherNode<H>
    Payload commitment.
    §
    type Share = Share<E, H>
    Share-specific data sent to a storage node.
    §
    type Common = Common<E, H>
    Common data sent to all storage nodes.
    source§
    fn commit_only<B>(&mut self, payload: B) -> VidResult<Self::Commit>
    where\n    B: AsRef<[u8]>,
    Compute a payload commitment
    source§
    fn disperse<B>(&mut self, payload: B) -> VidResult<VidDisperse<Self>>
    where\n    B: AsRef<[u8]>,
    Compute shares to send to the storage nodes
    source§
    fn verify_share(\n    &self,\n    share: &Self::Share,\n    common: &Self::Common,\n    commit: &Self::Commit,\n) -> VidResult<Result<(), ()>>
    Verify a share. Used by both storage node and retrieval client.\nWhy is return type a nested Result? See https://sled.rs/errors\nReturns: Read more
    source§
    fn recover_payload(\n    &self,\n    shares: &[Self::Share],\n    common: &Self::Common,\n) -> VidResult<Vec<u8>>
    Recover payload from shares.\nDo not verify shares or check recovered payload against anything.
    source§
    fn is_consistent(commit: &Self::Commit, common: &Self::Common) -> VidResult<()>
    Check that a VidScheme::Common is consistent with a\nVidScheme::Commit. Read more
    source§
    fn get_payload_byte_len(common: &Self::Common) -> u32
    Extract the payload byte length data from a VidScheme::Common.
    source§
    fn get_num_storage_nodes(common: &Self::Common) -> u32
    Extract the number of storage nodes from a VidScheme::Common.
    source§
    fn get_multiplicity(common: &Self::Common) -> u32
    Extract the number of poly evals per share VidScheme::Common.
    ","VidScheme","jf_vid::advz::Advz"],["
    source§
    impl<E, H: Eq, T> Eq for AdvzInternal<E, H, T>
    where\n    E: Pairing + Eq,\n    T: Sync + Eq,
    ","Eq","jf_vid::advz::Advz"],["
    source§
    impl<E, H, T> StructuralPartialEq for AdvzInternal<E, H, T>
    where\n    E: Pairing,\n    T: Sync,
    ","StructuralPartialEq","jf_vid::advz::Advz"]]
 };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file