Trait SWCurveConfig

pub trait SWCurveConfig: CurveConfig {
    const COEFF_A: <Self as CurveConfig>::BaseField;
    const COEFF_B: <Self as CurveConfig>::BaseField;
    const GENERATOR: Affine<Self>;

    // Provided methods
    fn mul_by_a(elem: Self::BaseField) -> Self::BaseField { ... }
    fn add_b(elem: Self::BaseField) -> Self::BaseField { ... }
    fn is_in_correct_subgroup_assuming_on_curve(item: &Affine<Self>) -> bool { ... }
    fn clear_cofactor(item: &Affine<Self>) -> Affine<Self> { ... }
    fn mul_projective(
        base: &Projective<Self>,
        scalar: &[u64],
    ) -> Projective<Self> { ... }
    fn mul_affine(base: &Affine<Self>, scalar: &[u64]) -> Projective<Self> { ... }
    fn msm(
        bases: &[Affine<Self>],
        scalars: &[Self::ScalarField],
    ) -> Result<Projective<Self>, usize> { ... }
    fn serialize_with_mode<W>(
        item: &Affine<Self>,
        writer: W,
        compress: Compress,
    ) -> Result<(), SerializationError>
       where W: Write { ... }
    fn deserialize_with_mode<R>(
        reader: R,
        compress: Compress,
        validate: Validate,
    ) -> Result<Affine<Self>, SerializationError>
       where R: Read { ... }
    fn serialized_size(compress: Compress) -> usize { ... }
}

Constants and convenience functions that collectively define the Short Weierstrass model of the curve. In this model, the curve equation is y² = x³ + a * x + b, for constants a and b.

Required Associated Constants

const COEFF_A: <Self as CurveConfig>::BaseField

Coefficient a of the curve equation.

const COEFF_B: <Self as CurveConfig>::BaseField

Coefficient b of the curve equation.

const GENERATOR: Affine<Self>

Generator of the prime-order subgroup.

Provided Methods

fn mul_by_a(elem: Self::BaseField) -> Self::BaseField

Helper method for computing elem * Self::COEFF_A.

The default implementation should be overridden only if the product can be computed faster than standard field multiplication (eg: via doubling if COEFF_A == 2, or if COEFF_A.is_zero()).

fn add_b(elem: Self::BaseField) -> Self::BaseField

Helper method for computing elem + Self::COEFF_B.

The default implementation should be overridden only if the sum can be computed faster than standard field addition (eg: via doubling).

fn is_in_correct_subgroup_assuming_on_curve(item: &Affine<Self>) -> bool

Check if the provided curve point is in the prime-order subgroup.

The default implementation multiplies item by the order r of the prime-order subgroup, and checks if the result is zero. If the curve’s cofactor is one, this check automatically returns true. Implementors can choose to override this default impl if the given curve has faster methods for performing this check (for example, via leveraging curve isomorphisms).

fn clear_cofactor(item: &Affine<Self>) -> Affine<Self>

Performs cofactor clearing. The default method is simply to multiply by the cofactor. Some curves can implement a more efficient algorithm.

fn mul_projective(base: &Projective<Self>, scalar: &[u64]) -> Projective<Self>

Default implementation of group multiplication for projective coordinates

fn mul_affine(base: &Affine<Self>, scalar: &[u64]) -> Projective<Self>

Default implementation of group multiplication for affine coordinates.

fn msm( bases: &[Affine<Self>], scalars: &[Self::ScalarField], ) -> Result<Projective<Self>, usize>

Default implementation for multi scalar multiplication

fn serialize_with_mode<W>( item: &Affine<Self>, writer: W, compress: Compress, ) -> Result<(), SerializationError>

where W: Write,

If uncompressed, serializes both x and y coordinates as well as a bit for whether it is infinity. If compressed, serializes x coordinate with two bits to encode whether y is positive, negative, or infinity.

fn deserialize_with_mode<R>( reader: R, compress: Compress, validate: Validate, ) -> Result<Affine<Self>, SerializationError>

where R: Read,

If validate is Yes, calls check() to make sure the element is valid.

fn serialized_size(compress: Compress) -> usize

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors