Struct secp256kfun::XOnly

pub struct XOnly(_);

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

Using a Point<EvenY,..> is usually the right choice as it serializes the same way and can do everything an XOnly 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 XOnly

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

Converts a 32-byte big-endian encoded x-coordinate into an XOnly. 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::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 from a random number generator.

Example

use secp256kfun::{marker::*, XOnly};
let random_x_coordinate = XOnly::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 XOnly

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

Decompresses a XOnly into a Point<EvenY,Public,NonZero>. The resulting point will have an even y-coordinate.

Example

use secp256kfun::{marker::*, XOnly};
let xonly = XOnly::random(&mut rand::thread_rng());
// get the point with a even y-coordinate
let point_even_y = xonly.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. 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::from_scalar_mul(G, &mut secret_key);
assert_ne!(secret_key, original);
assert_eq!(-secret_key, original);

Trait Implementations

impl Clone for XOnly

fn clone(&self) -> XOnly

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for XOnly

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

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

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

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

Deserialize this value from the given Serde deserializer.

impl Display for XOnly

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

Displays as hex.

impl From<XOnly> for Point<EvenY, Public, NonZero>

fn from(xonly: XOnly) -> Self

Performs the conversion.

impl FromStr for XOnly

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

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

type Err = HexError

The associated error which can be returned from parsing.

impl Hash for XOnly

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, 

Feeds a slice of this type into the given Hasher.

impl HashInto for XOnly

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

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

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

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

This method tests for !=.

impl PartialEq<XOnly> for XOnly

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

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

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

This method tests for !=.

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

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

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

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

This method tests for !=.

impl Serialize for XOnly

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

Serialize this value into the given Serde serializer.

impl Copy for XOnly

impl Eq for XOnly

impl StructuralEq for XOnly