Struct Scalar

pub struct Scalar<E: Curve>(/* private fields */);

Scalar modulo curve E group order

Scalar is an integer modulo curve E group order.

Implementations

impl<E: Curve> Scalar<E>

pub fn zero() -> Self

Returns scalar $S = 0$

use generic_ec::{Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let s = Scalar::<Secp256k1>::random(&mut OsRng);
assert_eq!(s * Scalar::zero(), Scalar::zero());
assert_eq!(s + Scalar::zero(), s);

pub fn is_zero(&self) -> bool

Checks whether the scalar is zero

pub fn one() -> Self

Returns scalar $S = 1$

use generic_ec::{Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let s = Scalar::<Secp256k1>::random(&mut OsRng);
assert_eq!(s * Scalar::one(), s);

pub fn invert(&self) -> Option<Self>

Returns scalar inverse $S^{-1}$

Inverse of scalar $S$ is a scalar $S^{-1}$ such as $S \cdot S^{-1} = 1$. Inverse doesn’t exist only for scalar $S = 0$, so function returns None if scalar is zero.

use generic_ec::{Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let s = Scalar::<Secp256k1>::random(&mut OsRng);
let s_inv = s.invert()?;
assert_eq!(s * s_inv, Scalar::one());

pub fn ct_invert(&self) -> CtOption<Self>

Returns scalar inverse $S^{-1}$ (constant time)

Same as Scalar::invert but performs constant-time check on whether it’s zero scalar

pub fn to_be_bytes(&self) -> EncodedScalar<E>

Encodes scalar as bytes in big-endian order

use generic_ec::{Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let s = Scalar::<Secp256k1>::random(&mut OsRng);
let bytes = s.to_be_bytes();
println!("Scalar hex representation: {}", hex::encode(bytes));

pub fn to_le_bytes(&self) -> EncodedScalar<E>

Encodes scalar as bytes in little-endian order

pub fn from_be_bytes(bytes: impl AsRef<[u8]>) -> Result<Self, InvalidScalar>

Decodes scalar from its representation as bytes in big-endian order

Returns error if encoded integer is larger than group order.

use generic_ec::{Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let s = Scalar::<Secp256k1>::random(&mut OsRng);
let s_bytes = s.to_be_bytes();
let s_decoded = Scalar::from_be_bytes(&s_bytes)?;
assert_eq!(s, s_decoded);

pub fn from_le_bytes(bytes: impl AsRef<[u8]>) -> Result<Self, InvalidScalar>

Decodes scalar from its representation as bytes in little-endian order

Returns error if encoded integer is larger than group order.

pub fn from_be_bytes_mod_order(bytes: impl AsRef<[u8]>) -> Self

Interprets provided bytes as integer $i$ in big-endian order, returns scalar $s = i \mod q$

pub fn from_le_bytes_mod_order(bytes: impl AsRef<[u8]>) -> Self

Interprets provided bytes as integer $i$ in little-endian order, returns scalar $s = i \mod q$

pub fn random<R: RngCore>(rng: &mut R) -> Self

Generates random non-zero scalar

Algorithm is based on rejection sampling: we sample a scalar, if it’s zero try again. It may be considered constant-time as zero scalar appears with $2^{-256}$ probability which is considered to be negligible.

Panics

Panics if randomness source returned 100 zero scalars in a row. It happens with $2^{-25600}$ probability, which practically means that randomness source is broken.

pub fn from_hash<D: Digest>(data: &impl Digestable) -> Self

Available on crate feature hash-to-scalar only.

Hashes the input and outputs scalar

Input can be any structured data that implements Digestable trait (see udigest crate).

How it works

It works by instantiating HashRng CSPRNG seeded from provided data. Then it’s used to derive the scalar.

Security considerations

It’s not constant time. It doesn’t follow any existing standards for hash to scalar primitive.

Example

use generic_ec::{Scalar, curves::Secp256k1};
use sha2::Sha256;

#[derive(udigest::Digestable)]
struct Data<'a> {
    nonce: &'a [u8],
    param_a: &'a str,
    param_b: u128,
    // ...
}

let scalar = Scalar::<Secp256k1>::from_hash::<Sha256>(&Data {
    nonce: b"some data",
    param_a: "some other data",
    param_b: 12345,
    // ...
});

pub fn serialized_len() -> usize

Returns size of bytes buffer that can fit serialized scalar

pub fn as_radix16_be(&self) -> Radix16Iter<E>

Returns scalar big-endian representation in radix $2^4 = 16$

Radix 16 representation is defined as sum:

$$s = s_0 + s_1 16^1 + s_2 16^2 + \dots + s_{\log_{16}(s) - 1} 16^{\log_{16}(s) - 1}$$

(note: we typically work with 256 bit scalars, so $\log_{16}(s) = \log_{16}(2^{256}) = 64$)

Returns iterator over coefficients from most to least significant: $s_{\log_{16}(s) - 1}, \dots, s_1, s_0$

pub fn as_radix16_le(&self) -> Radix16Iter<E>

Returns scalar little-endian representation in radix $2^4 = 16$

Radix 16 representation is defined as sum:

$$s = s_0 + s_1 16^1 + s_2 16^2 + \dots + s_{\log_{16}(s) - 1} 16^{\log_{16}(s) - 1}$$

(note: we typically work with 256 bit scalars, so $\log_{16}(s) = \log_{16}(2^{256}) = 64$)

Returns iterator over coefficients from least to most significant: $s_0, s_1, \dots, s_{\log_{16}(s) - 1}$

pub fn multiscalar_mul<S, P>( scalar_points: impl ExactSizeIterator<Item = (S, P)>, ) -> Point<E>

where S: AsRef<Scalar<E>>, P: AsRef<Point<E>>,

Performs multiscalar multiplication

Takes iterator of pairs (scalar, point). Returns sum of scalar * point. Uses Default algorithm.

See multiscalar module docs for more info.

Trait Implementations

impl<E: Curve> Add<&NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: SecretScalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: SecretScalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> AddAssign<&NonZero<Scalar<E>>> for Scalar<E>

fn add_assign(&mut self, rhs: &NonZero<Scalar<E>>)

Performs the += operation.

impl<E: Curve> AddAssign<&NonZero<SecretScalar<E>>> for Scalar<E>

fn add_assign(&mut self, rhs: &NonZero<SecretScalar<E>>)

Performs the += operation.

impl<E: Curve> AddAssign<&Scalar<E>> for Scalar<E>

fn add_assign(&mut self, rhs: &Scalar<E>)

Performs the += operation.

impl<E: Curve> AddAssign<&SecretScalar<E>> for Scalar<E>

fn add_assign(&mut self, rhs: &SecretScalar<E>)

Performs the += operation.

impl<E: Curve> AddAssign<NonZero<Scalar<E>>> for Scalar<E>

fn add_assign(&mut self, rhs: NonZero<Scalar<E>>)

Performs the += operation.

impl<E: Curve> AddAssign<NonZero<SecretScalar<E>>> for Scalar<E>

fn add_assign(&mut self, rhs: NonZero<SecretScalar<E>>)

Performs the += operation.

impl<E: Curve> AddAssign<SecretScalar<E>> for Scalar<E>

fn add_assign(&mut self, rhs: SecretScalar<E>)

Performs the += operation.

impl<E: Curve> AddAssign for Scalar<E>

fn add_assign(&mut self, rhs: Scalar<E>)

Performs the += operation.

impl<E: Curve> AsRaw for Scalar<E>

type Raw = <E as Curve>::Scalar

Wrapped point/scalar

fn as_raw(&self) -> &E::Scalar

Returns reference to wrapped value

impl<E: Curve> AsRef<Scalar<E>> for NonZero<SecretScalar<E>>

fn as_ref(&self) -> &Scalar<E>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E: Curve> AsRef<Scalar<E>> for Scalar<E>

fn as_ref(&self) -> &Scalar<E>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E: Curve> AsRef<Scalar<E>> for SecretScalar<E>

fn as_ref(&self) -> &Scalar<E>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E: Clone + Curve> Clone for Scalar<E>

where E::Scalar: Clone,

fn clone(&self) -> Scalar<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Curve> ConditionallySelectable for Scalar<E>

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

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<E: Curve> ConstantTimeEq for Scalar<E>

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<E: Curve> Debug for Scalar<E>

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

Formats the value using the given formatter.

impl<E: Default + Curve> Default for Scalar<E>

where E::Scalar: Default,

fn default() -> Scalar<E>

Returns the “default value” for a type.

impl<'de, E: Curve> Deserialize<'de> for Scalar<E>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, E: Curve> DeserializeAs<'de, Scalar<E>> for Compact

Available on crate feature serde only.

fn deserialize_as<D>(deserializer: D) -> Result<Scalar<E>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: Curve> Digestable for Scalar<E>

Available on crate feature udigest only.

fn unambiguously_encode<B>(&self, encoder: EncodeValue<'_, B>)

where B: Buffer,

Unambiguously encodes the value

impl<E: Curve> From<NonZero<Scalar<E>>> for Scalar<E>

fn from(scalar: NonZero<Scalar<E>>) -> Self

Converts to this type from the input type.

impl<E: Curve> From<i128> for Scalar<E>

fn from(i: i128) -> Self

Converts to this type from the input type.

impl<E: Curve> From<i16> for Scalar<E>

fn from(i: i16) -> Self

Converts to this type from the input type.

impl<E: Curve> From<i32> for Scalar<E>

fn from(i: i32) -> Self

Converts to this type from the input type.

impl<E: Curve> From<i64> for Scalar<E>

fn from(i: i64) -> Self

Converts to this type from the input type.

impl<E: Curve> From<i8> for Scalar<E>

fn from(i: i8) -> Self

Converts to this type from the input type.

impl<E: Curve> From<u128> for Scalar<E>

fn from(i: u128) -> Self

Converts to this type from the input type.

impl<E: Curve> From<u16> for Scalar<E>

fn from(i: u16) -> Self

Converts to this type from the input type.

impl<E: Curve> From<u32> for Scalar<E>

fn from(i: u32) -> Self

Converts to this type from the input type.

impl<E: Curve> From<u64> for Scalar<E>

fn from(i: u64) -> Self

Converts to this type from the input type.

impl<E: Curve> From<u8> for Scalar<E>

fn from(i: u8) -> Self

Converts to this type from the input type.

impl<E: Curve> From<usize> for Scalar<E>

fn from(i: usize) -> Self

Converts to this type from the input type.

impl<E: Curve> FromRaw for Scalar<E>

fn from_raw(scalar: E::Scalar) -> Self

Infallibly wraps raw value

impl<E: Curve> Hash for Scalar<E>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E: Curve> IsZero for Scalar<E>

fn is_zero(&self) -> bool

Checks whether self is zero

impl<E: Curve> Mul<&Generator<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Generator<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Generator<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Generator<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<Point<E>>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<Point<E>>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Generator<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Generator<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Generator<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Generator<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Point<E>>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Point<E>>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> MulAssign<&NonZero<Scalar<E>>> for Scalar<E>

fn mul_assign(&mut self, rhs: &NonZero<Scalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<&NonZero<SecretScalar<E>>> for Scalar<E>

fn mul_assign(&mut self, rhs: &NonZero<SecretScalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<&Scalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: &Scalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<&Scalar<E>> for Scalar<E>

fn mul_assign(&mut self, rhs: &Scalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<&SecretScalar<E>> for Scalar<E>

fn mul_assign(&mut self, rhs: &SecretScalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<NonZero<Scalar<E>>> for Scalar<E>

fn mul_assign(&mut self, rhs: NonZero<Scalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<NonZero<SecretScalar<E>>> for Scalar<E>

fn mul_assign(&mut self, rhs: NonZero<SecretScalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<Scalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: Scalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<SecretScalar<E>> for Scalar<E>

fn mul_assign(&mut self, rhs: SecretScalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign for Scalar<E>

fn mul_assign(&mut self, rhs: Scalar<E>)

Performs the *= operation.

impl<E: Curve> Neg for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> One for Scalar<E>

fn one() -> Self

Constructs one value of Self

fn is_one(x: &Self) -> Choice

Checks (in constant-time) if x is one

impl<E: Curve> Ord for Scalar<E>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<E: Curve> PartialEq<NonZero<Scalar<E>>> for Scalar<E>

fn eq(&self, other: &NonZero<Scalar<E>>) -> bool

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

const 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<E: PartialEq + Curve> PartialEq for Scalar<E>

where E::Scalar: PartialEq,

fn eq(&self, other: &Scalar<E>) -> bool

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

const 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<E: Curve> PartialOrd<NonZero<Scalar<E>>> for Scalar<E>

fn partial_cmp(&self, other: &NonZero<Scalar<E>>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E: Curve> PartialOrd for Scalar<E>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, E: Curve> Product<&'a Scalar<E>> for Scalar<E>

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'s, E: Curve> Product<&'s SecretScalar<E>> for Scalar<E>

fn product<I: Iterator<Item = &'s SecretScalar<E>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve> Product<SecretScalar<E>> for Scalar<E>

fn product<I: Iterator<Item = SecretScalar<E>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve> Product for Scalar<E>

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

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve, const N: usize> Reduce<N> for Scalar<E>

where E::Scalar: Reduce<N>,

fn from_be_array_mod_order(bytes: &[u8; N]) -> Self

Interprets bytes as big-endian encoding of an integer, returns this integer modulo curve (prime) order

fn from_le_array_mod_order(bytes: &[u8; N]) -> Self

Interprets bytes as little-endian encoding of an integer, returns this integer modulo curve (prime) order

impl<E: Curve> Samplable for Scalar<E>

fn random<R: RngCore>(rng: &mut R) -> Self

Uniformely samples a random value of Self

impl<E: Curve> Serialize for Scalar<E>

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Curve> SerializeAs<Scalar<E>> for Compact

Available on crate feature serde only.

fn serialize_as<S>(source: &Scalar<E>, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<SecretScalar<E>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: SecretScalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<SecretScalar<E>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: SecretScalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> SubAssign<&NonZero<Scalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: &NonZero<Scalar<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign<&NonZero<SecretScalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: &NonZero<SecretScalar<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign<&Scalar<E>> for Scalar<E>

fn sub_assign(&mut self, rhs: &Scalar<E>)

Performs the -= operation.

impl<E: Curve> SubAssign<&SecretScalar<E>> for Scalar<E>

fn sub_assign(&mut self, rhs: &SecretScalar<E>)

Performs the -= operation.

impl<E: Curve> SubAssign<NonZero<Scalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: NonZero<Scalar<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign<NonZero<SecretScalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: NonZero<SecretScalar<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign<SecretScalar<E>> for Scalar<E>

fn sub_assign(&mut self, rhs: SecretScalar<E>)

Performs the -= operation.

impl<E: Curve> SubAssign for Scalar<E>

fn sub_assign(&mut self, rhs: Scalar<E>)

Performs the -= operation.

impl<'s, E: Curve> Sum<&'s NonZero<Scalar<E>>> for Scalar<E>

fn sum<I: Iterator<Item = &'s NonZero<Scalar<E>>>>(iter: I) -> Self

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

impl<'a, E: Curve> Sum<&'a Scalar<E>> for Scalar<E>

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

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

impl<'s, E: Curve> Sum<&'s SecretScalar<E>> for Scalar<E>

fn sum<I: Iterator<Item = &'s SecretScalar<E>>>(iter: I) -> Self

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

impl<E: Curve> Sum<NonZero<Scalar<E>>> for Scalar<E>

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

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

impl<E: Curve> Sum<SecretScalar<E>> for Scalar<E>

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

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

impl<E: Curve> Sum for Scalar<E>

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

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

impl<E: Curve> TryFrom<Scalar<E>> for NonZero<Scalar<E>>

type Error = ZeroScalar

The type returned in the event of a conversion error.

fn try_from(scalar: Scalar<E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<E: Curve> Zero for Scalar<E>

fn zero() -> Self

Constructs zero value of Self

fn is_zero(x: &Self) -> Choice

Checks (in constant-time) if x is zero

impl<E: Curve> Zeroize for Scalar<E>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<E: Copy + Curve> Copy for Scalar<E>

where E::Scalar: Copy,

impl<E: Eq + Curve> Eq for Scalar<E>

where E::Scalar: Eq,

impl<E: Curve> StructuralPartialEq for Scalar<E>