Struct Scalar 

#[repr(C, align(32))]
pub struct Scalar(/* 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 Secp256k1Scalar

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 Secp256k1Scalar

pub fn get_non_qr() -> &'static Secp256k1Scalar

impl Secp256k1Scalar

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

Returns the SEC1 encoding of this scalar.

Trait Implementations

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

type Output = Secp256k1Scalar

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Secp256k1Scalar

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl AddAssign for Secp256k1Scalar

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AsRef<Secp256k1Scalar> for Secp256k1Scalar

fn as_ref(&self) -> &Secp256k1Scalar

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

impl Clone for Secp256k1Scalar

fn clone(&self) -> Secp256k1Scalar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionallySelectable for Secp256k1Scalar

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

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 Secp256k1Scalar

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 Secp256k1Scalar

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

Formats the value using the given formatter.

impl Default for Secp256k1Scalar

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Secp256k1Scalar

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 Secp256k1Scalar> for Secp256k1Scalar

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

Undefined behaviour when denominator is not coprime to N

impl DivAssignUnsafe for Secp256k1Scalar

fn div_assign_unsafe(&mut self, other: Self)

Undefined behaviour when denominator is not coprime to N

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

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

Undefined behaviour when denominator is not coprime to N

type Output = Secp256k1Scalar

Output type of div_unsafe.

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

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

Undefined behaviour when denominator is not coprime to N

type Output = Secp256k1Scalar

Output type of div_unsafe.

impl DivUnsafe for Secp256k1Scalar

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

Undefined behaviour when denominator is not coprime to N

type Output = Secp256k1Scalar

Output type of div_unsafe.

impl Field for Secp256k1Scalar

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 Secp256k1Scalar

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 Secp256k1Scalar

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<ScalarPrimitive<Secp256k1>> for Secp256k1Scalar

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

Converts to this type from the input type.

impl From<Secp256k1Scalar> for FieldBytes<Secp256k1>

fn from(scalar: Secp256k1Scalar) -> Self

Converts to this type from the input type.

impl From<Secp256k1Scalar> for ScalarPrimitive<Secp256k1>

fn from(scalar: Secp256k1Scalar) -> ScalarPrimitive<Secp256k1>

Converts to this type from the input type.

impl From<Secp256k1Scalar> for U256

fn from(scalar: Secp256k1Scalar) -> Self

Converts to this type from the input type.

impl From<u64> for Secp256k1Scalar

fn from(value: u64) -> Self

Converts to this type from the input type.

impl FromUintUnchecked for Secp256k1Scalar

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 Secp256k1Scalar

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 Secp256k1Scalar

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 Secp256k1Scalar

type Output = CtOption<Secp256k1Scalar>

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 Secp256k1Scalar

fn is_high(&self) -> Choice

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

impl Mul<&Secp256k1Scalar> for &Secp256k1Point

type Output = Secp256k1Point

The resulting type after applying the * operator.

fn mul(self, other: &Secp256k1Scalar) -> Secp256k1Point

Performs the * operation.

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

type Output = Secp256k1Scalar

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Secp256k1Scalar> for Secp256k1Point

type Output = Secp256k1Point

The resulting type after applying the * operator.

fn mul(self, other: &Secp256k1Scalar) -> Secp256k1Point

Performs the * operation.

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

type Output = Secp256k1Scalar

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Secp256k1Scalar> for Secp256k1Point

type Output = Secp256k1Point

The resulting type after applying the * operator.

fn mul(self, other: Secp256k1Scalar) -> Secp256k1Point

Performs the * operation.

impl Mul for Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Secp256k1Scalar> for Secp256k1Point

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

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssign<Secp256k1Scalar> for Secp256k1Point

fn mul_assign(&mut self, rhs: Secp256k1Scalar)

Performs the *= operation.

impl MulAssign for Secp256k1Scalar

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<'a> Neg for &'a Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Secp256k1Scalar

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 Secp256k1Scalar

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 Secp256k1Scalar

fn from_repr(bytes: FieldBytes<Secp256k1>) -> 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 = 6u32

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, <Secp256k1 as Curve>::FieldBytesSize>

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

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

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 Secp256k1Scalar> for Secp256k1Scalar

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

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

impl Product for Secp256k1Scalar

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 Secp256k1Scalar

type Bytes = GenericArray<u8, <Secp256k1 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<Secp256k1>) -> Self

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

impl Reduce for Secp256k1Scalar

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 Secp256k1Scalar

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 Secp256k1Scalar

fn shr_assign(&mut self, _rhs: usize)

Performs the >>= operation.

impl SignPrimitive<Secp256k1> for Scalar

fn try_sign_prehashed<K>( &self, _k: K, _z: &FieldBytes<Secp256k1>, ) -> Result<(Signature, Option<RecoveryId>)>

where K: AsRef<Self> + Invert<Output = CtOption<Self>>,

Try to sign the prehashed message.

fn try_sign_prehashed_rfc6979<D>( &self, z: &GenericArray<u8, <C as Curve>::FieldBytesSize>, ad: &[u8], ) -> Result<(Signature<C>, Option<RecoveryId>), Error>

where Self: From<ScalarPrimitive<C>> + Invert<Output = CtOption<Self>>, D: Digest<OutputSize = <C as Curve>::FieldBytesSize> + BlockSizeUser + FixedOutput + FixedOutputReset,

Try to sign the given message digest deterministically using the method described in RFC6979 for computing ECDSA ephemeral scalar k.

impl Sqrt for Secp256k1Scalar

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

Returns a square root of self if it exists.

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

type Output = Secp256k1Scalar

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub for &'a Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Secp256k1Scalar

type Output = Secp256k1Scalar

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl SubAssign for Secp256k1Scalar

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

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

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

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

impl Sum for Secp256k1Scalar

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 Secp256k1Scalar

impl DefaultIsZeroes for Secp256k1Scalar

impl Eq for Secp256k1Scalar