Struct PairwiseAuthKey 

#[repr(C)]
pub struct PairwiseAuthKey<A, B> {
    pub alpha: GlobalKey<A>,
    pub beta: B,
}

Generic authenticated key: a global key alpha: A and a local key beta: B, satisfying MAC(x) = α · x + β.

This is the base type for both:

• [FieldShareKey<F>] — single-value authenticated key
• [FieldShareKeys<F,M>] — batched authenticated key (M values, shared α)

Fields

alpha: GlobalKey<A>

beta: B

Implementations

impl<A, B> PairwiseAuthKey<A, B>

pub fn new(alpha: Arc<A>, beta: B) -> Self

Create a new PairwiseAuthKey with the given global key alpha and local key beta.

pub fn get_beta(&self) -> &B

Return a reference to the local key beta.

pub fn get_alpha(&self) -> &A

Return a reference to the global key alpha.

pub fn alpha(&self) -> Arc<A>

Return the value of the global key alpha.

impl<A: Clone, B: Copy, M: Positive> PairwiseAuthKey<A, HeapArray<B, M>>

Generic split and merge operations on any batched key PairwiseAuthKey<A, HeapArray<B, M>>. Covers both FieldShareKeys<F, M> and CurveKeys<C, M>.

pub fn split<M1, M2>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, M1>>, PairwiseAuthKey<A, HeapArray<B, M2>>)

where M1: Positive, M2: Positive + Add<M1, Output = M>,

Split a batched key into two smaller batched keys with the same global key alpha and disjoint local keys beta (first M1 values in the first key, next M2 values in the second key).

pub fn split_last_pos<M1>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, M1>>, PairwiseAuthKey<A, B>)

where M1: Positive + Add<B1, Output = M>,

pub fn split_halves<MDiv2>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, MDiv2>>, PairwiseAuthKey<A, HeapArray<B, MDiv2>>)

where MDiv2: Positive + Mul<U2, Output = M>,

Split a batched key into two smaller batched keys with the same global key alpha and disjoint local keys beta (first M/2 values in the first key, next M/2 values in the second key).

pub fn merge_halves( this: Self, other: Self, ) -> PairwiseAuthKey<A, HeapArray<B, Prod<M, U2>>>

where M: Positive + Mul<U2, Output: Positive>, A: PartialEq,

Merge two batched keys with the same global key alpha and disjoint local keys beta (first M/2 values in the first key, next M/2 values in the second key) into a single batched key with M values in the local key.

pub fn split3<M1, M2, M3>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, M1>>, PairwiseAuthKey<A, HeapArray<B, M2>>, PairwiseAuthKey<A, HeapArray<B, M3>>)

where M1: Positive, M2: Positive + Add<M1>, M3: Positive + Add<Sum<M2, M1>, Output = M>,

Split a batched key into three smaller batched keys with the same global key alpha and disjoint local keys beta (first M1 values in the first key, next M2 values in the second key, last M3 values in the third key).

pub fn split_thirds<MDiv3>( self, ) -> (PairwiseAuthKey<A, HeapArray<B, MDiv3>>, PairwiseAuthKey<A, HeapArray<B, MDiv3>>, PairwiseAuthKey<A, HeapArray<B, MDiv3>>)

where MDiv3: Positive + Mul<U3, Output = M>,

Split a batched key into three smaller batched keys with the same global key alpha and disjoint local keys beta (first M/3 values in the first key, next M/3 values in the second key, last M/3 values in the third key).

pub fn merge_thirds( first: Self, second: Self, third: Self, ) -> PairwiseAuthKey<A, HeapArray<B, Prod<M, U3>>>

where M: Positive + Mul<U3, Output: Positive>, A: PartialEq,

Merge three batched keys with the same global key alpha and disjoint local keys beta (first M/3 values in the first key, next M/3 values in the second key, last M/3 values in the third key) into a single batched key with M values in the local key.

Trait Implementations

impl<A: PartialEq, B> Add for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add<&PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, other: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add<&PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<A: PartialEq, B> Add<PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the + operator.

fn add(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the + operation.

impl<'a, A: PartialEq, B> AddAssign for PairwiseAuthKey<A, B>

where for<'b> B: AddAssign<&'b B>,

fn add_assign(&mut self, rhs: PairwiseAuthKey<A, B>)

Performs the += operation.

impl<'a, A: PartialEq, B> AddAssign<&'a PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'b> B: AddAssign<&'b B>,

fn add_assign(&mut self, other: &'a PairwiseAuthKey<A, B>)

Performs the += operation.

impl<A: Clone, B: Clone> Clone for PairwiseAuthKey<A, B>

fn clone(&self) -> PairwiseAuthKey<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: ConditionallySelectable, B: ConditionallySelectable> ConditionallySelectable for PairwiseAuthKey<A, B>

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

impl<A: ConstantTimeEq, B: ConstantTimeEq> ConstantTimeEq for PairwiseAuthKey<A, B>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<A: Debug, B: Debug> Debug for PairwiseAuthKey<A, B>

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

Formats the value using the given formatter.

impl<A: Default, B: Default> Default for PairwiseAuthKey<A, B>

fn default() -> PairwiseAuthKey<A, B>

Returns the “default value” for a type.

impl<'de, A, B> Deserialize<'de> for PairwiseAuthKey<A, B>

where A: Deserialize<'de>, B: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Eq, B: Eq> Eq for PairwiseAuthKey<A, B>

impl<A, T> From<PairwiseAuthKey<A, T>> for PairwiseAuthKey<A, HeapArray<T, U1>>

Convert a single-element key into a one-element batched key. Covers From<FieldShareKey<F>> for FieldShareKeys<F, U1> and From<CurveKey<C>> for CurveKeys<C, U1>.

fn from(key: PairwiseAuthKey<A, T>) -> Self

Converts to this type from the input type.

impl<C: Curve> From<PairwiseAuthKey<FieldElement<<C as Curve>::Scalar>, FieldElement<<C as Curve>::Scalar>>> for CurveKey<C>

fn from(scalar_key: ScalarKey<C>) -> Self

Converts to this type from the input type.

impl<C: Curve, M: Positive> From<PairwiseAuthKey<FieldElement<<C as Curve>::Scalar>, HeapArray<FieldElement<<C as Curve>::Scalar>, M>>> for CurveKeys<C, M>

fn from(scalar_key: ScalarKeys<C, M>) -> Self

Converts to this type from the input type.

impl<A: InPlaceCodec, B: InPlaceCodec> InPlaceCodec for PairwiseAuthKey<A, B>

const ENCODED_SIZE: usize

Encoded width in bytes.

fn write_le_bytes(&self, out: &mut [MaybeUninit<u8>])

Write self’s canonical encoding into out, initializing every byte. out.len() == Self::ENCODED_SIZE.

fn read_le_bytes(bytes: &[u8]) -> Result<Self, PrimitiveError>

Parse self from bytes, validating it. bytes.len() == Self::ENCODED_SIZE. Returns an error on an invalid (e.g. non-canonical) encoding.

const PACK: usize = 1

Number of consecutive elements that encode together as a “pack”. 1 (the default) means no grouping — each element is encoded independently via Self::write_le_bytes. Must be >= 1.

const PACK_BYTES: usize = _

Bytes a full PACK-element pack occupies. Defaults to PACK * ENCODED_SIZE (the packed bytes are exactly the per-element bytes laid out back-to-back — the case for a pure vectorization like Mersenne107). Override with a smaller value for a sub-byte packing (e.g. Gf2: PACK = 8, PACK_BYTES = 1).

fn write_pack(items: &[Self], out: &mut [MaybeUninit<u8>])

Encode exactly Self::PACK elements (items.len() == PACK) into out (out.len() == PACK_BYTES), initializing every byte.

fn read_pack( bytes: &[u8], out: &mut [MaybeUninit<Self>], ) -> Result<(), PrimitiveError>

Decode a full pack: read Self::PACK elements from bytes (bytes.len() == PACK_BYTES) into out (out.len() == PACK), returning an error on an invalid encoding.

fn to_inplace_bytes(&self) -> Vec<u8>

Serialize self into a freshly-allocated buffer of exactly Self::ENCODED_SIZE bytes, bypassing per-element serde dispatch.

fn from_inplace_bytes(bytes: &[u8]) -> Result<Self, PrimitiveError>

Deserialize Self from exactly Self::ENCODED_SIZE bytes.

impl<A, B, RHS, BPrime> Mul<RHS> for PairwiseAuthKey<A, B>

where B: Mul<RHS, Output = BPrime>,

type Output = PairwiseAuthKey<A, BPrime>

The resulting type after applying the * operator.

fn mul(self, other: RHS) -> Self::Output

Performs the * operation.

impl<A: Clone, B, RHS, BPrime> Mul<RHS> for &PairwiseAuthKey<A, B>

where for<'b> &'b B: Mul<RHS, Output = BPrime>,

type Output = PairwiseAuthKey<A, BPrime>

The resulting type after applying the * operator.

fn mul(self, other: RHS) -> Self::Output

Performs the * operation.

impl<A, B, RHS> MulAssign<RHS> for PairwiseAuthKey<A, B>

where B: MulAssign<RHS>,

fn mul_assign(&mut self, other: RHS)

Performs the *= operation.

impl<A, B: Neg<Output = B>> Neg for PairwiseAuthKey<A, B>

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B: Neg<Output = B>> Neg for &PairwiseAuthKey<A, B>

where PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A: PartialEq, B: PartialEq> PartialEq for PairwiseAuthKey<A, B>

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

Equality operator ==.

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

Inequality operator !=.

impl<A: Random, B: Random> Random for PairwiseAuthKey<A, B>

fn random(rng: impl CryptoRngCore) -> Self

fn random_n<Container: FromIterator<Self>>( rng: impl CryptoRngCore, size: usize, ) -> Container

fn random_array<M: Positive>(rng: impl CryptoRngCore) -> HeapArray<Self, M>

impl<A: Clone, B: Random> RandomWith<Arc<A>> for PairwiseAuthKey<A, B>

fn random_with(rng: impl CryptoRngCore, alpha: GlobalKey<A>) -> Self

fn random_n_with<Container: FromIterator<Self>>( rng: impl CryptoRngCore, size: usize, data: D, ) -> Container

fn random_n_with_each<Container: FromIterator<Self>>( rng: impl CryptoRngCore, all_data: impl IntoExactSizeIterator<Item = D>, ) -> Container

impl<A, B> Serialize for PairwiseAuthKey<A, B>

where A: Serialize, B: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: PartialEq, B: PartialEq> StructuralPartialEq for PairwiseAuthKey<A, B>

impl<A: PartialEq, B> Sub for PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub<&PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, other: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub<&PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, B> Sub<PairwiseAuthKey<A, B>> for &PairwiseAuthKey<A, B>

where for<'a> B: Sub<&'a B, Output = B>, PairwiseAuthKey<A, B>: Clone,

type Output = PairwiseAuthKey<A, B>

The resulting type after applying the - operator.

fn sub(self, rhs: PairwiseAuthKey<A, B>) -> Self::Output

Performs the - operation.

impl<'a, A: PartialEq, B> SubAssign for PairwiseAuthKey<A, B>

where for<'b> B: SubAssign<&'b B>,

fn sub_assign(&mut self, rhs: PairwiseAuthKey<A, B>)

Performs the -= operation.

impl<'a, A: PartialEq, B> SubAssign<&'a PairwiseAuthKey<A, B>> for PairwiseAuthKey<A, B>

where for<'b> B: SubAssign<&'b B>,

fn sub_assign(&mut self, other: &'a PairwiseAuthKey<A, B>)

Performs the -= operation.

impl<A: Default + PartialEq, B> Sum for PairwiseAuthKey<A, B>

where for<'a> B: Add<&'a B, Output = B> + Default,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.