Struct fuel_crypto::Signature

source ·

#[repr(transparent)]
pub struct Signature(_);

Expand description

Secp256k1 signature implementation

Implementations§

source §

impl Signature

source

pub fn sign(secret: &SecretKey, message: &Message) -> Self

Available on crate feature std only.

Sign a given message and compress the v to the signature

The compression scheme is described in https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic_primitives.md

source

pub fn recover(self, message: &Message) -> Result<PublicKey, Error>

Available on crate feature std only.

Recover the public key from a signature performed with Signature::sign

It takes the signature as owned because this operation is not idempotent. The taken signature will not be recoverable. Signatures are meant to be single use, so this avoids unnecessary copy.

source

pub fn verify(self, pk: &PublicKey, message: &Message) -> Result<(), Error>

Available on crate feature std only.

Verify a signature produced by Signature::sign

It takes the signature as owned because this operation is not idempotent. The taken signature will not be recoverable. Signatures are meant to be single use, so this avoids unnecessary copy.

source §

impl Signature

source

pub const LEN: usize = 64usize

Memory length of the type in bytes.

source

pub fn from_bytes(bytes: [u8; 64]) -> Self

Construct a Signature directly from its bytes.

This constructor expects the given bytes to be a valid signature. No signing is performed.

source

pub fn from_bytes_ref(bytes: &[u8; 64]) -> &Self

Construct a Signature reference directly from a reference to its bytes.

This constructor expects the given bytes to be a valid signature. No signing is performed.

source

pub fn from_bytes_unchecked(bytes: [u8; 64]) -> Self

👎Deprecated: Use Signature::from_bytes instead

Kept temporarily for backwards compatibility.

Methods from Deref<Target = [u8; 64]>§

1.57.0 · source

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

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.

#![feature(array_methods)]

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);

source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (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, &[]);
}

source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (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]);
}

source

pub fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters, or returns None if any of the characters is non-ASCII.

Examples

#![feature(ascii_char)]
#![feature(const_option)]

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");