unyt-org · janiejestemja · Nov 29, 2025 · Nov 29, 2025 · Nov 30, 2025 · Dec 1, 2025
diff --git a/Cargo.toml b/Cargo.toml
@@ -63,6 +63,7 @@ serde-big-array = { version = "0.5.1", optional = true }
 realhydroper-lsp = { version = "0.22.0", optional = true, default-features = false, features = [
     "proposed",
 ] }
+bs58 = { version = "0.5.1", default-features = false }
 
 # macros
 strum_macros = { version = "0.27.1" }

diff --git a/src/crypto/crypto.rs b/src/crypto/crypto.rs
@@ -1,123 +1,154 @@
 use crate::stdlib::boxed::Box;
 use crate::stdlib::string::String;
 use crate::stdlib::vec::Vec;
+use crate::stdlib::{future::Future, pin::Pin};
+use bs58;
 use core::fmt::Display;
 use core::prelude::rust_2024::*;
 use core::result::Result;
+pub type CryptoResult<'a, T> =
+    Pin<Box<dyn Future<Output = Result<T, CryptoError>> + 'a>>;
 
-use crate::stdlib::{future::Future, pin::Pin};
 pub trait CryptoTrait: Send + Sync {
     /// Creates a new UUID.
     fn create_uuid(&self) -> String;
 
     /// Generates cryptographically secure random bytes of the specified length.
     fn random_bytes(&self, length: usize) -> Vec<u8>;
 
+    /// Sha256 hash
+    fn hash_sha256<'a>(
+        &'a self,
+        to_digest: &'a [u8],
+    ) -> CryptoResult<'a, [u8; 32]>;
+
+    /// Encodes 32 bytes to base58
+    fn enc_b58<'a>(
+        &'a self,
+        to_encode: &'a [u8; 32],
+    ) -> Result<[u8; 44], CryptoError> {
+        let mut out_buf = [0u8; 44];
+        bs58::encode(to_encode)
+            .onto(&mut out_buf[..])
+            .map_err(|_| CryptoError::Decryption)?;
+        Ok(out_buf)
+    }
+
+    /// Decodes 32 bytes from base58
+    fn dec_b58<'a>(
+        &'a self,
+        to_decode: &'a [u8; 44],
+    ) -> Result<[u8; 32], CryptoError> {
+        let mut out_buf = [0u8; 32];
+        bs58::decode(to_decode)
+            .onto(&mut out_buf[..])
+            .map_err(|_| CryptoError::Decryption)?;
+        Ok(out_buf)
+    }
+
+    /// Hash key derivation function.
+    fn hkdf_sha256<'a>(
+        &'a self,
+        ikm: &'a [u8],
+        salt: &'a [u8],
+    ) -> CryptoResult<'a, [u8; 32]>;
+
     /// Generates an Ed25519 key pair.
-    fn gen_ed25519(
-        &self,
-    ) -> Pin<
-        Box<
-            dyn Future<Output = Result<(Vec<u8>, Vec<u8>), CryptoError>>
-                + 'static,
-        >,
-    >;
+    fn gen_ed25519<'a>(&'a self) -> CryptoResult<'a, (Vec<u8>, Vec<u8>)>;
 
     /// Signs data with the given Ed25519 private key.
     fn sig_ed25519<'a>(
         &'a self,
         pri_key: &'a [u8],
         data: &'a [u8],
-    ) -> Pin<Box<dyn Future<Output = Result<[u8; 64], CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, [u8; 64]>;
 
     /// Verifies an Ed25519 signature with the given public key and data.
     fn ver_ed25519<'a>(
         &'a self,
         pub_key: &'a [u8],
         sig: &'a [u8],
         data: &'a [u8],
-    ) -> Pin<Box<dyn Future<Output = Result<bool, CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, bool>;
 
     /// AES-256 in CTR mode encryption, returns the ciphertext.
     fn aes_ctr_encrypt<'a>(
         &'a self,
         key: &'a [u8; 32],
         iv: &'a [u8; 16],
         plaintext: &'a [u8],
-    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, Vec<u8>>;
 
     /// AES-256 in CTR mode decryption, returns the plaintext.
     fn aes_ctr_decrypt<'a>(
         &'a self,
         key: &'a [u8; 32],
         iv: &'a [u8; 16],
         cipher: &'a [u8],
-    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, Vec<u8>>;
 
     /// AES Key Wrap (RFC 3394), returns the wrapped key (ciphertext).
     fn key_upwrap<'a>(
         &'a self,
         kek_bytes: &'a [u8; 32],
         rb: &'a [u8; 32],
-    ) -> Pin<Box<dyn Future<Output = Result<[u8; 40], CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, [u8; 40]>;
 
     /// AES Key Unwrap (RFC 3394), returns the unwrapped key (plaintext).
     fn key_unwrap<'a>(
         &'a self,
         kek_bytes: &'a [u8; 32],
         cipher: &'a [u8; 40],
-    ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, [u8; 32]>;
 
     /// Generates an X25519 key pair, returns (public_key, private_key).
-    fn gen_x25519(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = Result<([u8; 44], [u8; 48]), CryptoError>>>>;
+    fn gen_x25519<'a>(&'a self) -> CryptoResult<'a, ([u8; 44], [u8; 48])>;
 
     /// Derives a shared secret using X25519 given my private key and the peer's public key.
     fn derive_x25519<'a>(
         &'a self,
         pri_key: &'a [u8; 48],
         peer_pub: &'a [u8; 44],
-    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + 'a>>;
+    ) -> CryptoResult<'a, Vec<u8>>;
 }
 
 pub struct Crypto;
 
 #[derive(Debug, Clone)]
 pub enum CryptoError {
     Other(String),
-    KeyGeneratorFailed,
-    KeyExportFailed,
-    KeyImportFailed,
-    EncryptionError,
-    DecryptionError,
-    SigningError,
-    VerificationError,
+    KeyGeneration,
+    KeyExport,
+    KeyImport,
+    Encryption,
+    Decryption,
+    Signing,
+    Verification,
 }
 
 impl Display for CryptoError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            CryptoError::Other(msg) => core::write!(f, "CryptoError: {}", msg),
-            CryptoError::KeyGeneratorFailed => {
+            CryptoError::Other(msg) => core::write!(f, "Crypto: {}", msg),
+            CryptoError::KeyGeneration => {
                 core::write!(f, "CryptoError: Key generation failed")
             }
-            CryptoError::KeyExportFailed => {
+            CryptoError::KeyExport => {
                 core::write!(f, "CryptoError: Key export failed")
             }
-            CryptoError::KeyImportFailed => {
+            CryptoError::KeyImport => {
                 core::write!(f, "CryptoError: Key import failed")
             }
-            CryptoError::EncryptionError => {
+            CryptoError::Encryption => {
                 core::write!(f, "CryptoError: Encryption failed")
             }
-            CryptoError::DecryptionError => {
+            CryptoError::Decryption => {
                 core::write!(f, "CryptoError: Decryption failed")
             }
-            CryptoError::SigningError => {
+            CryptoError::Signing => {
                 core::write!(f, "CryptoError: Signing failed")
             }
-            CryptoError::VerificationError => {
+            CryptoError::Verification => {
                 core::write!(f, "CryptoError: Verification failed")
             }
         }