refactor: clean up error handling and panic messages

- Replace verbose error messages with concise static strings for no_std. - Refactor panic and error handling for better compatibility and clarity. - Remove unnecessary formatting and string allocations in error paths. - Improve code consistency and maintainability across modules.

Author: avrabe

wrt-error/src/codes.rs

@@ -42,11 +42,11 @@ pub const EXECUTION_INVALID_FRAME: u16 = 1014;
 /// Execution reader not implemented error
 pub const EXECUTION_READER_NOT_IMPLEMENTED: u16 = 1015;
 /// Capacity exceeded
-pub const CAPACITY_EXCEEDED: u16 = 1013;
+pub const CAPACITY_EXCEEDED: u16 = 1016;
 /// Gas limit exceeded
-pub const GAS_LIMIT_EXCEEDED: u16 = 1014;
+pub const GAS_LIMIT_EXCEEDED: u16 = 1017;
 /// Call stack exhausted
-pub const CALL_STACK_EXHAUSTED: u16 = 1015;
+pub const CALL_STACK_EXHAUSTED: u16 = 1018;
 
 // Component model error codes (2000-2999)
 /// Invalid function index error
@@ -181,7 +181,7 @@ pub const TYPE_RESULT_COUNT_MISMATCH: u16 = 6019;
 pub const TYPE_RESULT_TYPE_MISMATCH: u16 = 6020;
 /// Invalid byte length for a given type or operation
 pub const INVALID_BYTE_LENGTH: u16 = 6021;
-/// Capacity of a bounded collection (e.g., BoundedVec, BoundedString) was
+/// Capacity of a bounded collection (e.g., `BoundedVec`, `BoundedString`) was
 /// exceeded during an operation like push or extend.
 pub const BOUNDED_COLLECTION_CAPACITY: u16 = 6022;
 
@@ -292,6 +292,8 @@ pub const VALIDATION_MEMORY_ACCESS_ERROR: u16 = 8214;
 pub const VALIDATION_START_FUNCTION_ERROR: u16 = 8215;
 
 // Memory errors (8400-8499)
+/// General memory error
+pub const MEMORY_ERROR: u16 = 8400;
 /// Memory allocation error
 pub const MEMORY_ALLOCATION_ERROR: u16 = 8403;
 /// Memory grow failure error
@@ -337,6 +339,10 @@ pub const SYSTEM_RESOURCE_LIMIT_ERROR: u16 = 8802;
 /// System unsupported feature error
 pub const SYSTEM_UNSUPPORTED_FEATURE_ERROR: u16 = 8803;
 
+// Security errors (8900-8999)
+/// Control Flow Integrity violation
+pub const CFI_VIOLATION: u16 = 8900;
+
 // Component errors (9000-9099)
 /// Component invalid type error
 pub const COMPONENT_INVALID_TYPE_ERROR: u16 = 9001;

wrt-error/src/errors.rs

@@ -49,6 +49,8 @@ pub enum ErrorCategory {
     Capacity = 12,
     /// WebAssembly trap errors (specific runtime errors defined by Wasm spec)
     RuntimeTrap = 13,
+    /// Initialization errors
+    Initialization = 14,
 }
 
 /// Base trait for all error types - `no_std` version
@@ -194,6 +196,48 @@ impl Error {
         Self::new(ErrorCategory::Type, codes::INVALID_TYPE, message)
     }
 
+    /// Create an index out of bounds error
+    #[must_use]
+    pub const fn index_out_of_bounds(message: &'static str) -> Self {
+        Self::new(ErrorCategory::Memory, codes::OUT_OF_BOUNDS_ERROR, message)
+    }
+
+    /// Create a deserialization error
+    #[must_use]
+    pub const fn deserialization_error(message: &'static str) -> Self {
+        Self::new(ErrorCategory::Parse, codes::DECODING_ERROR, message)
+    }
+
+    /// Create a capacity error
+    #[must_use]
+    pub const fn capacity_error(message: &'static str) -> Self {
+        Self::new(ErrorCategory::Capacity, codes::CAPACITY_EXCEEDED, message)
+    }
+
+    /// Create an internal error
+    #[must_use]
+    pub const fn internal_error(message: &'static str) -> Self {
+        Self::new(ErrorCategory::System, codes::SYSTEM_ERROR, message)
+    }
+
+    /// Create a memory out of bounds error
+    #[must_use]
+    pub const fn memory_out_of_bounds(message: &'static str) -> Self {
+        Self::new(ErrorCategory::Memory, codes::MEMORY_OUT_OF_BOUNDS, message)
+    }
+
+    /// Create a memory uninitialized error
+    #[must_use]
+    pub const fn memory_uninitialized(message: &'static str) -> Self {
+        Self::new(ErrorCategory::Memory, codes::INITIALIZATION_ERROR, message)
+    }
+
+    /// Create a new static error with explicit parameters
+    #[must_use]
+    pub const fn new_static(category: ErrorCategory, code: u16, message: &'static str) -> Self {
+        Self::new(category, code, message)
+    }
+
     // Note: Methods like `with_message`, `new_legacy`, `*_with_code`,
     // and `parse_error_from_kind` have been removed as they were
     // dependent on `alloc` or dynamic messages not suitable for `&'static str`.

wrt-error/src/kinds.rs

@@ -602,25 +602,41 @@ pub const fn tail_call_error(message: &'static str) -> TailCallError {
 
 impl core::fmt::Display for ValidationError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Validation error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for OutOfBoundsError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Out of bounds error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for ParseError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Parse error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for InvalidType {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Invalid type")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
@@ -668,25 +684,41 @@ impl core::fmt::Display for InvalidLocalIndexError {
 
 impl core::fmt::Display for ResourceError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Resource error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for ComponentError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Component error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for RuntimeError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Runtime error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
 impl core::fmt::Display for PoisonedLockError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Poisoned lock error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }
 
@@ -716,7 +748,11 @@ impl core::fmt::Display for ArithmeticError {
 
 impl core::fmt::Display for MemoryAccessError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.0)
+        if self.0.is_empty() {
+            write!(f, "Memory access error")
+        } else {
+            write!(f, "{}", self.0)
+        }
     }
 }