Struct P256Scalar 

#[repr(C, align(32))]
pub struct P256Scalar(/* private fields */);

An element of the ring of integers modulo a positive integer. The element is internally represented as a fixed size array of bytes.

Caution

It is not guaranteed that the integer representation is less than the modulus. After any arithmetic operation, the honest host should normalize the result to its canonical representation less than the modulus, but guest execution does not require it.

See assert_reduced and is_reduced.

Implementations

impl P256Scalar

pub const fn from_const_bytes(bytes: [u8; 32]) -> Self

Constructor from little-endian bytes. Does not enforce the integer value of bytes must be less than the modulus.

impl P256Scalar

pub fn get_non_qr() -> &'static P256Scalar

impl P256Scalar

pub fn to_bytes(&self) -> FieldBytes<NistP256>

Returns the SEC1 encoding of this scalar.

Trait Implementations

impl<'a> Add<&'a P256Scalar> for &P256Scalar

type Output = P256Scalar

The resulting type after applying the + operator.

fn add(self, other: &'a P256Scalar) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a P256Scalar> for P256Scalar

type Output = P256Scalar

The resulting type after applying the + operator.

fn add(self, other: &'a P256Scalar) -> Self::Output

Performs the + operation.

impl Add for P256Scalar

type Output = P256Scalar

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<'a> AddAssign<&'a P256Scalar> for P256Scalar

fn add_assign(&mut self, other: &'a P256Scalar)

Performs the += operation.

impl AddAssign for P256Scalar

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AsRef<P256Scalar> for P256Scalar

fn as_ref(&self) -> &P256Scalar

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

impl Clone for P256Scalar

fn clone(&self) -> P256Scalar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionallySelectable for P256Scalar

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

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 ConstantTimeEq for P256Scalar

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 Debug for P256Scalar

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

Formats the value using the given formatter.

impl Default for P256Scalar

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for P256Scalar

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> DivAssignUnsafe<&'a P256Scalar> for P256Scalar

fn div_assign_unsafe(&mut self, other: &'a P256Scalar)

Undefined behaviour when denominator is not coprime to N

impl DivAssignUnsafe for P256Scalar

fn div_assign_unsafe(&mut self, other: Self)

Undefined behaviour when denominator is not coprime to N

impl<'a> DivUnsafe<&'a P256Scalar> for &P256Scalar

fn div_unsafe(self, other: &'a P256Scalar) -> Self::Output

Undefined behaviour when denominator is not coprime to N

type Output = P256Scalar

Output type of div_unsafe.

impl<'a> DivUnsafe<&'a P256Scalar> for P256Scalar

fn div_unsafe(self, other: &'a P256Scalar) -> Self::Output

Undefined behaviour when denominator is not coprime to N

type Output = P256Scalar

Output type of div_unsafe.

impl DivUnsafe for P256Scalar

fn div_unsafe(self, other: Self) -> Self::Output

Undefined behaviour when denominator is not coprime to N

type Output = P256Scalar

Output type of div_unsafe.

impl Field for P256Scalar

const ZERO: Self = <Self as ::openvm_algebra_guest::IntMod>::ZERO

The zero element of the field, the additive identity.

const ONE: Self = <Self as ::openvm_algebra_guest::IntMod>::ONE

The one element of the field, the multiplicative identity.

type SelfRef<'a> = &'a P256Scalar

fn double_assign(&mut self)

Doubles self in-place.

fn square_assign(&mut self)

Square self in-place

fn invert(&self) -> Self

Unchecked inversion. See DivUnsafe.

impl Field for P256Scalar

const ZERO: Self = <Self as IntMod>::ZERO

The zero element of the field, the additive identity.

const ONE: Self = <Self as IntMod>::ONE

The one element of the field, the multiplicative identity.

fn random(_rng: impl RngCore) -> Self

Returns an element chosen uniformly at random using a user-provided RNG.

fn square(&self) -> Self

Squares this element.

fn double(&self) -> Self

Doubles this element.

fn invert(&self) -> CtOption<Self>

Computes the multiplicative inverse of this element, failing if the element is zero.

fn sqrt(&self) -> CtOption<Self>

Returns the square root of the field element, if it is quadratic residue.

fn sqrt_ratio(num: &Self, div: &Self) -> (Choice, Self)

Computes:

fn is_zero(&self) -> Choice

Returns true iff this element is zero.

fn is_zero_vartime(&self) -> bool

Returns true iff this element is zero.

fn cube(&self) -> Self

Cubes this element.

fn sqrt_alt(&self) -> (Choice, Self)

Equivalent to Self::sqrt_ratio(self, one()).

fn pow<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

fn pow_vartime<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

impl From<P256Scalar> for FieldBytes<NistP256>

fn from(scalar: P256Scalar) -> Self

Converts to this type from the input type.

impl From<P256Scalar> for ScalarPrimitive<NistP256>

fn from(scalar: P256Scalar) -> ScalarPrimitive<NistP256>

Converts to this type from the input type.

impl From<P256Scalar> for U256

fn from(scalar: P256Scalar) -> Self

Converts to this type from the input type.

impl From<ScalarPrimitive<NistP256>> for P256Scalar

fn from(scalar: ScalarPrimitive<NistP256>) -> Self

Converts to this type from the input type.

impl From<u64> for P256Scalar

fn from(value: u64) -> Self

Converts to this type from the input type.

impl FromUintUnchecked for P256Scalar

type Uint = Uint<crypto_bigint::::uint::U256::{constant#0}>

Unsigned integer type (i.e. Curve::Uint)

fn from_uint_unchecked(uint: Self::Uint) -> Self

Instantiate scalar from an unsigned integer without checking whether the value overflows the field modulus.

impl IntMod for P256Scalar

fn assert_reduced(&self)

If self is not in its canonical form, the proof will fail to verify. This means guest execution will never terminate (either successfully or unsuccessfully) if self is not in its canonical form.

const MODULUS: Self::Repr

Modulus as a Repr.

const ZERO: Self

The zero element (i.e. the additive identity).

const NUM_LIMBS: usize = 32usize

Number of limbs used to internally represent an element of Self.

const ONE: Self

The one element (i.e. the multiplicative identity).

type Repr = [u8; 32]

Underlying representation of IntMod. Usually of the form [u8; NUM_LIMBS].

type SelfRef<'a> = &'a P256Scalar

SelfRef<'a> should almost always be &'a Self. This is a way to include implementations of binary operations where both sides are &'a Self.

fn from_repr(repr: Self::Repr) -> Self

Creates a new IntMod from an instance of Repr. Does not enforce the integer value of bytes must be less than the modulus.

fn from_le_bytes(bytes: &[u8]) -> Option<Self>

Creates a new IntMod from an array of bytes, little endian. Returns None if the integer value of bytes is greater than or equal to the modulus.

fn from_be_bytes(bytes: &[u8]) -> Option<Self>

Creates a new IntMod from an array of bytes, big endian. Returns None if the integer value of bytes is greater than or equal to the modulus.

fn from_le_bytes_unchecked(bytes: &[u8]) -> Self

Creates a new IntMod from an array of bytes, little endian. Does not enforce the integer value of bytes must be less than the modulus.

fn from_be_bytes_unchecked(bytes: &[u8]) -> Self

Creates a new IntMod from an array of bytes, big endian. Does not enforce the integer value of bytes must be less than the modulus.

fn from_u8(val: u8) -> Self

Creates a new IntMod from a u8. Does not enforce the integer value of bytes must be less than the modulus.

fn from_u32(val: u32) -> Self

Creates a new IntMod from a u32. Does not enforce the integer value of bytes must be less than the modulus.

fn from_u64(val: u64) -> Self

Creates a new IntMod from a u64. Does not enforce the integer value of bytes must be less than the modulus.

fn as_le_bytes(&self) -> &[u8]

Value of this IntMod as an array of bytes, little endian.

fn to_be_bytes(&self) -> [u8; 32]

Value of this IntMod as an array of bytes, big endian.

fn modulus_biguint() -> BigUint

Modulus N as a BigUint.

fn from_biguint(biguint: BigUint) -> Self

Creates a new IntMod from a BigUint.

fn as_biguint(&self) -> BigUint

Value of this IntMod as a BigUint.

fn neg_assign(&mut self)

fn double_assign(&mut self)

Doubles self in-place.

fn square_assign(&mut self)

Squares self in-place.

fn double(&self) -> Self

Doubles this IntMod.

fn square(&self) -> Self

Squares this IntMod.

fn cube(&self) -> Self

Cubes this IntMod.

fn is_reduced(&self) -> bool

Is the integer representation of self less than the modulus?

fn set_up_once()

Calls any setup required for this modulus. The implementation should internally use OnceBool to ensure that setup is only called once.

unsafe fn eq_impl<const CHECK_SETUP: bool>(&self, other: &Self) -> bool

Returns whether the two integers are congrument modulo the modulus.

unsafe fn add_ref<const CHECK_SETUP: bool>(&self, other: &Self) -> Self

Add two elements.

impl Invert for P256Scalar

type Output = CtOption<P256Scalar>

Field element type

fn invert(&self) -> CtOption<Self>

Invert a field element.

fn invert_vartime(&self) -> Self::Output

Invert a field element in variable time.

impl IsHigh for P256Scalar

fn is_high(&self) -> Choice

Is this scalar greater than or equal to n / 2?

impl Mul<&P256Scalar> for &P256Point

type Output = P256Point

The resulting type after applying the * operator.

fn mul(self, other: &P256Scalar) -> P256Point

Performs the * operation.

impl<'a> Mul<&'a P256Scalar> for &P256Scalar

type Output = P256Scalar

The resulting type after applying the * operator.

fn mul(self, other: &'a P256Scalar) -> Self::Output

Performs the * operation.

impl Mul<&P256Scalar> for P256Point

type Output = P256Point

The resulting type after applying the * operator.

fn mul(self, other: &P256Scalar) -> P256Point

Performs the * operation.

impl<'a> Mul<&'a P256Scalar> for P256Scalar

type Output = P256Scalar

The resulting type after applying the * operator.

fn mul(self, other: &'a P256Scalar) -> Self::Output

Performs the * operation.

impl Mul<P256Scalar> for P256Point

type Output = P256Point

The resulting type after applying the * operator.

fn mul(self, other: P256Scalar) -> P256Point

Performs the * operation.

impl Mul for P256Scalar

type Output = P256Scalar

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&P256Scalar> for P256Point

fn mul_assign(&mut self, rhs: &P256Scalar)

Performs the *= operation.

impl<'a> MulAssign<&'a P256Scalar> for P256Scalar

fn mul_assign(&mut self, other: &'a P256Scalar)

Performs the *= operation.

impl MulAssign<P256Scalar> for P256Point

fn mul_assign(&mut self, rhs: P256Scalar)

Performs the *= operation.

impl MulAssign for P256Scalar

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<'a> Neg for &'a P256Scalar

type Output = P256Scalar

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for P256Scalar

type Output = P256Scalar

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for P256Scalar

fn eq(&self, other: &Self) -> 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 PartialOrd for P256Scalar

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 PrimeField for P256Scalar

fn from_repr(bytes: FieldBytes<NistP256>) -> CtOption<Self>

Attempts to parse the given byte array as an SEC1-encoded scalar.

Returns None if the byte array does not contain a big-endian integer in the range [0, p).

const MODULUS: &'static str = ORDER_HEX

Modulus of the field written as a string for debugging purposes.

const NUM_BITS: u32 = 256u32

How many bits are needed to represent an element of this field.

const CAPACITY: u32 = 255u32

How many bits of information can be reliably stored in the field element.

const TWO_INV: Self

Inverse of $2$ in the field.

const MULTIPLICATIVE_GENERATOR: Self

A fixed multiplicative generator of modulus - 1 order. This element must also be a quadratic nonresidue.

const S: u32 = 4u32

An integer s satisfying the equation 2^s * t = modulus - 1 with t odd.

const ROOT_OF_UNITY: Self

The 2^s root of unity.

const ROOT_OF_UNITY_INV: Self

Inverse of Self::ROOT_OF_UNITY.

const DELTA: Self

Generator of the t-order multiplicative subgroup.

type Repr = GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>

The prime field can be converted back and forth into this binary representation.

fn to_repr(&self) -> FieldBytes<NistP256>

Converts an element of the prime field into the standard byte representation for this field.

fn is_odd(&self) -> Choice

Returns true iff this element is odd.

fn from_str_vartime(s: &str) -> Option<Self>

Interpret a string of numbers as a (congruent) prime field element. Does not accept unnecessary leading zeroes or a blank string.

fn from_u128(v: u128) -> Self

Obtains a field element congruent to the integer v.

fn from_repr_vartime(repr: Self::Repr) -> Option<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

fn is_even(&self) -> Choice

Returns true iff this element is even.

impl<'a> Product<&'a P256Scalar> for P256Scalar

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

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

impl Product for P256Scalar

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

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

impl Reduce<Uint<crypto_bigint::::uint::U256::{constant#0}>> for P256Scalar

type Bytes = GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>

Bytes used as input to Reduce::reduce_bytes.

fn reduce(w: U256) -> Self

Perform a modular reduction, returning a field element.

fn reduce_bytes(bytes: &FieldBytes<NistP256>) -> Self

Interpret the given bytes as an integer and perform a modular reduction.

impl Reduce for P256Scalar

fn reduce_le_bytes(bytes: &[u8]) -> Self

Interpret the given bytes as an integer and perform a modular reduction.

fn reduce_be_bytes(bytes: &[u8]) -> Self

impl Serialize for P256Scalar

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ShrAssign<usize> for P256Scalar

fn shr_assign(&mut self, _rhs: usize)

Performs the >>= operation.

impl Sqrt for P256Scalar

fn sqrt(&self) -> Option<Self>

Returns a square root of self if it exists.

impl<'a> Sub<&'a P256Scalar> for P256Scalar

type Output = P256Scalar

The resulting type after applying the - operator.

fn sub(self, other: &'a P256Scalar) -> Self::Output

Performs the - operation.

impl<'a> Sub for &'a P256Scalar

type Output = P256Scalar

The resulting type after applying the - operator.

fn sub(self, other: &'a P256Scalar) -> Self::Output

Performs the - operation.

impl Sub for P256Scalar

type Output = P256Scalar

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<'a> SubAssign<&'a P256Scalar> for P256Scalar

fn sub_assign(&mut self, other: &'a P256Scalar)

Performs the -= operation.

impl SubAssign for P256Scalar

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<'a> Sum<&'a P256Scalar> for P256Scalar

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

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

impl Sum for P256Scalar

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

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

impl Copy for P256Scalar

impl DefaultIsZeroes for P256Scalar

impl Eq for P256Scalar