pub struct PublicKey(/* private fields */);
Expand description
This is a public key, which identifies an actor (usually a person) and is shared.
Implementations§
source§impl PublicKey
impl PublicKey
sourcepub fn as_hex_string(&self) -> String
pub fn as_hex_string(&self) -> String
Render into a hexadecimal string
Consider converting .into()
a PublicKeyHex
which is a wrapped type rather than a naked String
sourcepub fn try_from_hex_string(v: &str, verify: bool) -> Result<PublicKey, Error>
pub fn try_from_hex_string(v: &str, verify: bool) -> Result<PublicKey, Error>
Create from a hexadecimal string
If verify is true, will verify that it works as a XOnlyPublicKey. This has a performance cost.
sourcepub fn as_bech32_string(&self) -> String
pub fn as_bech32_string(&self) -> String
Export as a bech32 encoded string
sourcepub fn as_xonly_public_key(&self) -> XOnlyPublicKey
pub fn as_xonly_public_key(&self) -> XOnlyPublicKey
Export as XOnlyPublicKey
sourcepub fn try_from_bech32_string(s: &str, verify: bool) -> Result<PublicKey, Error>
pub fn try_from_bech32_string(s: &str, verify: bool) -> Result<PublicKey, Error>
Import from a bech32 encoded string
If verify is true, will verify that it works as a XOnlyPublicKey. This has a performance cost.
sourcepub fn from_bytes(bytes: &[u8], verify: bool) -> Result<PublicKey, Error>
pub fn from_bytes(bytes: &[u8], verify: bool) -> Result<PublicKey, Error>
Import from raw bytes
sourcepub fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), Error>
pub fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), Error>
Verify a signed message
sourcepub fn hyperloglog_hash32(&self, offset: usize) -> u32
pub fn hyperloglog_hash32(&self, offset: usize) -> u32
This provides a u32 hash input for HyperLogLog that is based on NIP-45 (pr #1561). This works with the original HyperLogLog
sourcepub fn hyperloglog_hash64(&self, offset: usize) -> u64
pub fn hyperloglog_hash64(&self, offset: usize) -> u64
This provides a u64 hash input for HyperLogLog++ that is based on NIP-45 (pr #1561). This works with Google’s HyperLogLog++
Methods from Deref<Target = [u8; 32]>§
sourcepub fn as_ascii(&self) -> Option<&[AsciiChar; N]>
🔬This is a nightly-only experimental API. (ascii_char
)
pub fn as_ascii(&self) -> Option<&[AsciiChar; N]>
ascii_char
)Converts this array of bytes into an array of ASCII characters,
or returns None
if any of the characters is non-ASCII.
§Examples
#![feature(ascii_char)]
const HEX_DIGITS: [std::ascii::Char; 16] =
*b"0123456789abcdef".as_ascii().unwrap();
assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");
sourcepub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]
🔬This is a nightly-only experimental API. (ascii_char
)
pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]
ascii_char
)Converts this array of bytes into an array of ASCII characters, without checking whether they’re valid.
§Safety
Every byte in the array must be in 0..=127
, or else this is UB.
1.57.0 · sourcepub fn as_slice(&self) -> &[T]
pub fn as_slice(&self) -> &[T]
Returns a slice containing the entire array. Equivalent to &s[..]
.
1.77.0 · sourcepub fn each_ref(&self) -> [&T; N]
pub fn each_ref(&self) -> [&T; N]
Borrows each element and returns an array of references with the same
size as self
.
§Example
let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
This method is particularly useful if combined with other methods, like
map
. This way, you can avoid moving the original
array if its elements are not Copy
.
let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);
// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);
sourcepub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
🔬This is a nightly-only experimental API. (split_array
)
pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
split_array
)Divides one array reference into two at an index.
The first will contain all indices from [0, M)
(excluding
the index M
itself) and the second will contain all
indices from [M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let v = [1, 2, 3, 4, 5, 6];
{
let (left, right) = v.split_array_ref::<0>();
assert_eq!(left, &[]);
assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}
{
let (left, right) = v.split_array_ref::<2>();
assert_eq!(left, &[1, 2]);
assert_eq!(right, &[3, 4, 5, 6]);
}
{
let (left, right) = v.split_array_ref::<6>();
assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
assert_eq!(right, &[]);
}
sourcepub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
🔬This is a nightly-only experimental API. (split_array
)
pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
split_array
)Divides one array reference into two at an index from the end.
The first will contain all indices from [0, N - M)
(excluding
the index N - M
itself) and the second will contain all
indices from [N - M, N)
(excluding the index N
itself).
§Panics
Panics if M > N
.
§Examples
#![feature(split_array)]
let v = [1, 2, 3, 4, 5, 6];
{
let (left, right) = v.rsplit_array_ref::<0>();
assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
assert_eq!(right, &[]);
}
{
let (left, right) = v.rsplit_array_ref::<2>();
assert_eq!(left, &[1, 2, 3, 4]);
assert_eq!(right, &[5, 6]);
}
{
let (left, right) = v.rsplit_array_ref::<6>();
assert_eq!(left, &[]);
assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}
Trait Implementations§
source§impl<'de> Deserialize<'de> for PublicKey
impl<'de> Deserialize<'de> for PublicKey
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
source§impl From<&PublicKey> for PublicKeyHex
impl From<&PublicKey> for PublicKeyHex
source§fn from(pk: &PublicKey) -> PublicKeyHex
fn from(pk: &PublicKey) -> PublicKeyHex
source§impl From<PublicKey> for PublicKeyHex
impl From<PublicKey> for PublicKeyHex
source§fn from(pk: PublicKey) -> PublicKeyHex
fn from(pk: PublicKey) -> PublicKeyHex
source§impl Ord for PublicKey
impl Ord for PublicKey
source§impl PartialOrd for PublicKey
impl PartialOrd for PublicKey
source§impl<'a, C: Context> Readable<'a, C> for PublicKey
impl<'a, C: Context> Readable<'a, C> for PublicKey
fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error>
fn minimum_bytes_needed() -> usize
fn read_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> Result<Self, <C as Context>::Error>
fn read_with_length_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> (Result<Self, <C as Context>::Error>, usize)
fn read_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> Result<Self, <C as Context>::Error>
fn read_with_length_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)
fn read_with_length_from_buffer_copying_data_with_ctx_mut( context: &mut C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)
fn read_from_stream_unbuffered_with_ctx<S>(
context: C,
stream: S,
) -> Result<Self, <C as Context>::Error>where
S: Read,
fn read_from_stream_buffered_with_ctx<S>(
context: C,
stream: S,
) -> Result<Self, <C as Context>::Error>where
S: Read,
fn read_from_file_with_ctx( context: C, path: impl AsRef<Path>, ) -> Result<Self, <C as Context>::Error>
source§impl TryFrom<&PublicKeyHex> for PublicKey
impl TryFrom<&PublicKeyHex> for PublicKey
source§impl TryFrom<PublicKeyHex> for PublicKey
impl TryFrom<PublicKeyHex> for PublicKey
source§impl<C: Context> Writable<C> for PublicKey
impl<C: Context> Writable<C> for PublicKey
fn write_to<T: ?Sized + Writer<C>>( &self, writer: &mut T, ) -> Result<(), C::Error>
fn bytes_needed(&self) -> Result<usize, C::Error>
fn write_to_buffer_with_ctx( &self, context: C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>
fn write_to_buffer_with_ctx_mut( &self, context: &mut C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>
fn write_to_vec_with_ctx( &self, context: C, ) -> Result<Vec<u8>, <C as Context>::Error>
fn write_to_vec_with_ctx_mut( &self, context: &mut C, ) -> Result<Vec<u8>, <C as Context>::Error>
fn write_to_stream_with_ctx<S>(
&self,
context: C,
stream: S,
) -> Result<(), <C as Context>::Error>where
S: Write,
fn write_to_file_with_ctx( &self, context: C, path: impl AsRef<Path>, ) -> Result<(), <C as Context>::Error>
impl Copy for PublicKey
impl Eq for PublicKey
impl StructuralPartialEq for PublicKey
Auto Trait Implementations§
impl Freeze for PublicKey
impl RefUnwindSafe for PublicKey
impl Send for PublicKey
impl Sync for PublicKey
impl Unpin for PublicKey
impl UnwindSafe for PublicKey
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)