Struct secp256kfun::XOnly

pub struct XOnly<YChoice = ()>(_, _);

An XOnly<Y> is the compressed representation of a Point<T,S,Z> which only stores the x-coordinate of the point.

The type parameter Y determines how to decompress the x-only into a point. Y is always a YChoice or () if the y-coordinate is unspecified (in which case it can't be decompressed).

Instead of using an XOnly<Y> it is often more practical to use a Point<T,S,Z> where T is set to a YChoice. For example, a Point<EvenY,..> can do everything an XOnly<EvenY> can do and more. XOnly exists because sometimes all you need is the x-coordinate and you don't want to store the full point in memory.

Implementations

impl<Y> XOnly<Y>

pub fn from_bytes(bytes: [u8; 32]) -> Option<Self>

Converts a 32-byte big-endian encoded x-coordinate into an XOnly<Y>. Returns None if the bytes do not represent a valid x-coordinate on the curve.

Example

use secp256kfun::{marker::*, XOnly};
// note: x = 1 is on the curve.
// choose the even y-corrdinate when decompressing
assert!(XOnly::<EvenY>::from_bytes([1u8; 32]).is_some());
// choose the squaure y-corrdinate when decompressing
assert!(XOnly::<SquareY>::from_bytes([1u8; 32]).is_some());

pub fn from_slice(slice: &[u8]) -> Option<Self>

Convenience method for calling from_bytes on a slice. Returns None if the length of the slice is not 32.

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

Generates a random valid XOnly<Y> from a random number generator.

Example

use secp256kfun::{marker::*, XOnly};
let random_x_coordinate = XOnly::<EvenY>::random(&mut rand::thread_rng());

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

Returns a reference to the internal 32-byte slice.

pub fn into_bytes(self) -> [u8; 32]

Converts an XOnly into a 32-byte array.

impl<Y: YChoice> XOnly<Y>

pub fn to_point(&self) -> Point<Y, Public, NonZero>

Decompresses a XOnly<Y: YChoice> into a [Point<Y,Public,NonZero>]. The resulting point will have its y-coordinate chosen depending on Y and is marked as such.

Example

use secp256kfun::{marker::*, XOnly};
let xonly = XOnly::<EvenY>::random(&mut rand::thread_rng());
// get the point with a even y-coordinate
let point_even_y = xonly.to_point();
// get the point with a square y-coordinate
let point_square_y = xonly.mark::<SquareY>().to_point();

pub fn from_scalar_mul<GT>(G: &Point<GT>, x: &mut Scalar<impl Secrecy>) -> Self

Multiplies G by x and then compresses the point to an XOnly<Y: YChoice>. x is mutable because it will be negated if, after the multiplication, the resulting point doesn't match Y (negating it ensures that it does).

Example

use secp256kfun::{marker::*, Scalar, XOnly, G};
use std::str::FromStr;
let original = Scalar::<Secret>::from_str(
    "ee673d13de31533a375b41d9e57731d9bb4dbddbd6c1d2364f15be40fd783346",
)
.unwrap();
let mut secret_key = original.clone();
let xonly_public_key = XOnly::<EvenY>::from_scalar_mul(G, &mut secret_key);
assert_ne!(secret_key, original);
assert_eq!(-secret_key, original);

Trait Implementations

impl<Y, YNew: YChoice> ChangeMark<XOnly<Y>> for YNew

type Out = XOnly<YNew>

The result type of marking T with Self

fn change_mark(xonly: XOnly<Y>) -> Self::Out

Marks item with Self.

impl<Y> ChangeMark<XOnly<Y>> for ()

type Out = XOnly<()>

The result type of marking T with Self

fn change_mark(xonly: XOnly<Y>) -> Self::Out

Marks item with Self.

impl<YChoice: Clone> Clone for XOnly<YChoice>

fn clone(&self) -> XOnly<YChoice>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Y> Debug for XOnly<Y>

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

Formats the type as hex and any markers on the type.

impl<'de, Y> Deserialize<'de> for XOnly<Y>

fn deserialize<Deser: Deserializer<'de>>(
    deserializer: Deser
) -> Result<XOnly<Y>, Deser::Error>

Deserialize this value from the given Serde deserializer.

impl<Y> Display for XOnly<Y>

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

Displays as hex.

impl<Y: YChoice> From<XOnly<Y>> for Point<Y, Public, NonZero>

fn from(xonly: XOnly<Y>) -> Self

Performs the conversion.

impl<Y> FromStr for XOnly<Y>

type Err = HexError

The associated error which can be returned from parsing.

fn from_str(hex: &str) -> Result<XOnly<Y>, HexError>

Parses the string as hex and interprets tries to convert the resulting byte array into the desired value.

impl<Y> HashInto for XOnly<Y>

fn hash_into(&self, hash: &mut impl Digest)

Asks the item to convert itself to bytes and add itself to hash.

impl<T, Z, S> PartialEq<Point<T, S, Z>> for XOnly<SquareY>

fn eq(&self, rhs: &Point<T, S, Z>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, Z, S> PartialEq<XOnly<SquareY>> for Point<T, S, Z>

fn eq(&self, rhs: &XOnly<SquareY>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Y> PartialEq<XOnly<Y>> for XOnly<Y>

fn eq(&self, rhs: &XOnly<Y>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Y> Serialize for XOnly<Y>

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

Serialize this value into the given Serde serializer.