Struct soroban_sdk::crypto::Crypto

impl Crypto

pub fn env(&self) -> &Env

pub fn sha256(&self, data: &Bytes) -> BytesN<32>

Returns the SHA-256 hash of the data.

pub fn keccak256(&self, data: &Bytes) -> BytesN<32>

Returns the Keccak-256 hash of the data.

pub fn ed25519_verify( &self, public_key: &BytesN<32>, message: &Bytes, signature: &BytesN<64> )

Verifies an ed25519 signature.

The signature is verified as a valid signature of the message by the ed25519 public key.

Panics

If the signature verification fails.

pub fn secp256k1_recover( &self, message_digest: &BytesN<32>, signature: &BytesN<64>, recorvery_id: u32 ) -> BytesN<65>

Recovers the ECDSA secp256k1 public key.

The public key returned is the SEC-1-encoded ECDSA secp256k1 public key that produced the 64-byte signature over a given 32-byte message digest, for a given recovery_id byte.

Auto Trait Implementations§

impl !UnwindSafe for Crypto

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T, C> Compare<&T> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare(&self, a: &&T, b: &&T) -> Result<Ordering, <C as Compare<&T>>::Error>

impl<T, U, E, C> Compare<(T, U)> for C
where C: Compare<T, Error = E, Error = E> + Compare,

type Error = E

fn compare( &self, a: &(T, U), b: &(T, U) ) -> Result<Ordering, <C as Compare<(T, U)>>::Error>

impl<T, U, V, E, C> Compare<(T, U, V)> for C
where C: Compare<T, Error = E, Error = E, Error = E> + Compare + Compare<V>,

type Error = E

fn compare( &self, a: &(T, U, V), b: &(T, U, V) ) -> Result<Ordering, <C as Compare<(T, U, V)>>::Error>

impl<T, U, V, W, E, C> Compare<(T, U, V, W)> for C
where C: Compare<T, Error = E, Error = E, Error = E, Error = E> + Compare + Compare<V> + Compare<W>,

type Error = E

fn compare( &self, a: &(T, U, V, W), b: &(T, U, V, W) ) -> Result<Ordering, <C as Compare<(T, U, V, W)>>::Error>

impl<T, U, V, W, X, E, C> Compare<(T, U, V, W, X)> for C
where C: Compare<T, Error = E, Error = E, Error = E, Error = E, Error = E> + Compare + Compare<V> + Compare<W> + Compare<X>,

type Error = E

fn compare( &self, a: &(T, U, V, W, X), b: &(T, U, V, W, X) ) -> Result<Ordering, <C as Compare<(T, U, V, W, X)>>::Error>

impl<T, C> Compare<Box<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Box<T>, b: &Box<T> ) -> Result<Ordering, <C as Compare<Box<T>>>::Error>

impl<T, C> Compare<Option<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Option<T>, b: &Option<T> ) -> Result<Ordering, <C as Compare<Option<T>>>::Error>

impl<T, C> Compare<Rc<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Rc<T>, b: &Rc<T> ) -> Result<Ordering, <C as Compare<Rc<T>>>::Error>

impl<T, C> Compare<Vec<T>> for C
where C: Compare<T>,

type Error = <C as Compare<T>>::Error

fn compare( &self, a: &Vec<T>, b: &Vec<T> ) -> Result<Ordering, <C as Compare<Vec<T>>>::Error>

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<E, T, U> IntoVal<E, T> for U
where E: Env, T: FromVal<E, U>,

fn into_val(&self, e: &E) -> T

impl<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<E, T, U> TryIntoVal<E, T> for U
where E: Env, T: TryFromVal<E, U>,

type Error = <T as TryFromVal<E, U>>::Error

fn try_into_val(&self, env: &E) -> Result<T, >::Error>

impl<V, T> VZip<V> for T
where V: MultiLane<T>,