Struct UnbatchableProofPart 

pub struct UnbatchableProofPart<B = BigNumDig>
where
    B: Big,
{
    pub l_hash_inc: u32,
    pub r: <B as Big>::Num,
}

The part of PoKE* (Proof of Knowledge of Exponent) proofs that can’t be batched. This is very small (serialized typically <20 bytes, most likely just 17 bytes).

Fields

l_hash_inc: u32

The number to increase a hash by to land on the next prime. Helps to more quickly generate/verify the prime number $l$.

r: <B as Big>::Num

A part of the proof, the residue of the element that’s proven, i.e. $r$ in $element = q*l + r$

Trait Implementations

impl<B> Clone for UnbatchableProofPart<B>

where B: Clone + Big, <B as Big>::Num: Clone,

fn clone(&self) -> UnbatchableProofPart<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B> Debug for UnbatchableProofPart<B>

where B: Big,

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

Formats the value using the given formatter.

impl<'de, B> Deserialize<'de> for UnbatchableProofPart<B>

where B: Big,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B> PartialEq for UnbatchableProofPart<B>

where B: PartialEq + Big, <B as Big>::Num: PartialEq,

fn eq(&self, other: &UnbatchableProofPart<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<B> Serialize for UnbatchableProofPart<B>

where B: Big,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<B> Storable for UnbatchableProofPart<B>

where B: Big,

type Serializable = UnbatchableProofPart<B>

The at-rest representation of this storable type.

async fn to_serializable( &self, _store: &impl BlockStore, ) -> Result<<UnbatchableProofPart<B> as Storable>::Serializable, Error>

Turn the current type into the at-rest representation of this type.

async fn from_serializable( _: Option<&Cid<64>>, serializable: <UnbatchableProofPart<B> as Storable>::Serializable, ) -> Result<UnbatchableProofPart<B>, Error>

Take an at-rest representation of this type and turn it into the in-memory representation. You can use the cid parameter to populate a cache.

fn persisted_as(&self) -> Option<&OnceCell<Cid<64>>>

Return a serialization cache, if it exists. By default, this always returns None.

fn store( &self, store: &impl BlockStore, ) -> impl Future<Output = Result<Cid<64>, Error>> + CondSend

where Self: CondSync,

Store this data type in a given BlockStore.

fn load( cid: &Cid<64>, store: &impl BlockStore, ) -> impl Future<Output = Result<Self, Error>> + CondSend

Try to load a value of this type from a CID.

impl<B> Eq for UnbatchableProofPart<B>

where B: Eq + Big, <B as Big>::Num: Eq,

impl<B> StructuralPartialEq for UnbatchableProofPart<B>

where B: Big,