Merge pull request #248 from klever-io/refactor/kos-web

Refactor/kos-web

Author: klever-patrick

Cargo.lock

@@ -47,7 +47,7 @@ homepage = "https://klever.org/"
 license = "Apache-2.0"
 repository = "https://github.com/klever-io/kos-rs"
 rust-version = "1.74.0"
-version = "0.2.41"
+version = "0.3.0"
 
 [workspace.dependencies]
 bech32 = "0.9.1"
@@ -86,9 +86,9 @@ enum_delegate = "0.2"
 serde = { version = "1.0", default-features = false }
 serde_json = "1.0"
 thiserror = "1.0"
-kos-mobile = { version = "0.2.41", path = "./packages/kos-mobile", default-features = false }
+kos-mobile = { version = "0.3.0", path = "./packages/kos-mobile", default-features = false }
 ecies = { version = "0.2.7", default-features = false, features = ["pure"] }
-kos = { version = "0.2.41", path = "./packages/kos", default-features = false, features = ["not-ksafe"] }
+kos = { version = "0.3.0", path = "./packages/kos", default-features = false, features = ["not-ksafe"] }
 
 # lightning
 lwk_common = "0.9.0"

Cargo.toml

@@ -30,5 +30,6 @@ kos = { workspace = true, features = ["not-ksafe"] }
 wasm-bindgen = { workspace = true }
 num-bigint = "0.4"
 num-traits = "0.2"
+bigdecimal = "0.4"
 kos-codec = { path = "../kos-codec" }
-
+thiserror = { workspace = true }

packages/kos-web/Cargo.toml

@@ -1,106 +1,110 @@
 use kos::chains::ChainError;
-use std::{error, fmt, str};
-use wasm_bindgen::JsValue;
-
-/// Crypto error variants
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum Error {
-    // Invalid string
-    InvalidString(String),
-    // JSON serialization error
-    JSONSerde(String),
-    // UnsupportedChain,
-    UnsupportedChain(String),
-    // InvalidMnemonic,
-    InvalidMnemonic(&'static str),
-    // InvalidPath,
-    InvalidPath(&'static str),
-    // InvalidPrivateKey,
-    InvalidPrivateKey(&'static str),
-    // InvalidPublicKey,
-    InvalidPublicKey(String),
-    // InvalidAddress,
-    InvalidAddress(String),
-    // InvalidChecksum,
-    InvalidChecksum(&'static str),
-    /// Invalid secp256k1 signature
-    InvalidSignature(&'static str),
-    /// Invalid secp256k1 signature message
-    InvalidMessage(String),
-    /// Out of preallocated memory
-    NotEnoughMemory(String),
-    /// Invalid Enum Variant
-    InvalidEnumVariant(String),
-    /// Invalid Len
-    InvalidLen(String),
-    /// InvalidNumberParse
-    InvalidNumberParse(String),
-    /// InvalidTransaction
-    InvalidTransaction(String),
-    /// WalletManagerError
-    WalletManager(String),
-    /// CipherError
-    Cipher(String),
-    /// TransportError
-    Transport(String),
-    /// DelegateError
-    Delegate(String),
+use std::{error, fmt};
+use wasm_bindgen::prelude::*;
+
+// Rust-only error type with associated data
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[wasm_bindgen]
+pub struct KOSError {
+    #[wasm_bindgen(skip)]
+    pub message: String,
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::InvalidString(e) => write!(f, "Invalid string: {e}"),
-            Error::JSONSerde(e) => write!(f, "JSON serialization: {e}"),
-            Error::UnsupportedChain(e) => write!(f, "Unsupported chain: {e}"),
-            Error::InvalidMnemonic(e) => write!(f, "Invalid mnemonic: {e}"),
-            Error::InvalidPath(e) => write!(f, "Invalid path: {e}"),
-            Error::InvalidPrivateKey(e) => write!(f, "Invalid private key: {e}"),
-            Error::InvalidPublicKey(e) => write!(f, "Invalid public key: {e}"),
-            Error::InvalidAddress(e) => write!(f, "Invalid address: {e}"),
-            Error::InvalidChecksum(e) => write!(f, "Invalid checksum: {e}"),
-            Error::InvalidSignature(e) => write!(f, "Invalid signature: {e}"),
-            Error::InvalidMessage(e) => write!(f, "Invalid message: {e}"),
-            Error::NotEnoughMemory(e) => write!(f, "Not enough memory: {e}"),
-            Error::InvalidEnumVariant(e) => write!(f, "Invalid Enum Variant error: {e}"),
-            Error::InvalidLen(e) => write!(f, "Invalid Len: {e}"),
-            Error::InvalidNumberParse(e) => write!(f, "Invalid number parse: {e}"),
-            Error::InvalidTransaction(e) => write!(f, "Invalid transaction: {e}"),
-            Error::WalletManager(e) => write!(f, "WalletManager error: {e}"),
-            Error::Cipher(e) => write!(f, "Cipher error: {e}"),
-            Error::Transport(e) => write!(f, "Transport error: {e}"),
-            Error::Delegate(e) => write!(f, "Delegate error: {e}"),
+#[wasm_bindgen]
+impl KOSError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: String) -> KOSError {
+        KOSError { message }
+    }
+
+    #[wasm_bindgen(js_name = getMessage)]
+    pub fn get_message(&self) -> String {
+        self.message.clone()
+    }
+}
+
+impl KOSError {
+    pub fn unsupported_chain(id: String) -> Self {
+        KOSError {
+            message: format!("UnsupportedChainError: Unsupported chain {id}"),
+        }
+    }
+
+    pub fn kos_delegate(msg: String) -> Self {
+        KOSError {
+            message: format!("KOSDelegateError: {msg}"),
+        }
+    }
+
+    pub fn hex_decode(msg: String) -> Self {
+        KOSError {
+            message: format!("HexDecodeError: {msg}"),
+        }
+    }
+
+    pub fn kos_number(msg: String) -> Self {
+        KOSError {
+            message: format!("KOSNumberError: {msg}"),
+        }
+    }
+
+    pub fn invalid_string(msg: String) -> Self {
+        KOSError {
+            message: format!("Invalid string: {msg}"),
+        }
+    }
+
+    pub fn json_serde(msg: String) -> Self {
+        KOSError {
+            message: format!("JSON serialization: {msg}"),
+        }
+    }
+
+    pub fn invalid_mnemonic(msg: String) -> Self {
+        KOSError {
+            message: format!("Invalid mnemonic: {msg}"),
+        }
+    }
+
+    pub fn wallet_manager(msg: String) -> Self {
+        KOSError {
+            message: format!("WalletManager error: {msg}"),
+        }
+    }
+
+    pub fn cipher(msg: String) -> Self {
+        KOSError {
+            message: format!("Cipher error: {msg}"),
         }
     }
 }
 
-impl From<serde_json::Error> for Error {
-    fn from(e: serde_json::Error) -> Self {
-        Self::JSONSerde(e.to_string())
+impl fmt::Display for KOSError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.message)
     }
 }
 
-impl error::Error for Error {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
+impl From<serde_json::Error> for KOSError {
+    fn from(e: serde_json::Error) -> Self {
+        KOSError::json_serde(e.to_string())
     }
 }
 
-impl From<Error> for JsValue {
-    fn from(e: Error) -> Self {
-        JsValue::from_str(&format!("{e}"))
+impl error::Error for KOSError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        None
     }
 }
 
-impl From<hex::FromHexError> for Error {
+impl From<hex::FromHexError> for KOSError {
     fn from(e: hex::FromHexError) -> Self {
-        Self::InvalidString(e.to_string())
+        KOSError::hex_decode(e.to_string())
     }
 }
 
-impl From<ChainError> for Error {
+impl From<ChainError> for KOSError {
     fn from(err: ChainError) -> Self {
-        Error::Delegate(err.to_string())
+        KOSError::kos_delegate(err.to_string())
     }
 }