chore(RUN): Remove unused HypervisorErrors

Author: adambratschikaye

rs/interfaces/src/execution_environment/errors.rs

@@ -1,4 +1,4 @@
-use ic_base_types::{CanisterIdError, NumBytes, PrincipalIdBlobParseError};
+use ic_base_types::{NumBytes, PrincipalIdBlobParseError};
 use ic_error_types::UserError;
 use ic_types::{methods::WasmMethod, CanisterId, CountBytes, Cycles, NumInstructions};
 use ic_wasm_types::{WasmEngineError, WasmInstrumentationError, WasmValidationError};
@@ -98,19 +98,8 @@ pub enum HypervisorError {
     /// An attempt was made to grow the canister's memory above its memory
     /// allocation.
     OutOfMemory,
-    /// An attempt to perform an operation that isn't allowed when the canister
-    /// is stopped.
-    CanisterStopped,
-    /// An attempt was made to use more cycles than was available in a call
-    /// context.
-    InsufficientCyclesInCall {
-        available: Cycles,
-        requested: Cycles,
-    },
     /// The principal ID specified by the canister is invalid.
     InvalidPrincipalId(PrincipalIdBlobParseError),
-    /// The canister ID specified by the canister is invalid.
-    InvalidCanisterId(CanisterIdError),
     /// The canister rejected the message.
     MessageRejected,
     /// An attempt was made to add more cycles to an outgoing call than
@@ -235,7 +224,10 @@ impl HypervisorError {
             ),
             Self::InstructionLimitExceeded => UserError::new(
                 E::CanisterInstructionLimitExceeded,
-                format!("Canister {} exceeded the instruction limit for single message execution.", canister_id),
+                format!(
+                    "Canister {} exceeded the instruction limit for single message execution.",
+                    canister_id
+                ),
             ),
             Self::InvalidWasm(err) => UserError::new(
                 E::CanisterInvalidWasm,
@@ -268,37 +260,15 @@ impl HypervisorError {
             ),
             Self::WasmReservedPages => UserError::new(
                 E::CanisterOutOfMemory,
-                format!(
-                    "Canister {} ran out of available Wasm memory.",
-                    canister_id
-                ),
-            ),
-            Self::CanisterStopped => UserError::new(
-                E::CanisterStopped,
-                format!("Canister {} is stopped", canister_id,),
-            ),
-            Self::InsufficientCyclesInCall {
-                available,
-                requested,
-            } => UserError::new(
-                E::InsufficientCyclesInCall,
-                format!(
-                    "Canister {} attempted to keep {} cycles from a call when only {} was available",
-                    canister_id, requested, available
-                ),
+                format!("Canister {} ran out of available Wasm memory.", canister_id),
             ),
             Self::InvalidPrincipalId(_) => UserError::new(
                 E::CanisterTrapped,
                 format!("Canister {} provided invalid principal id", canister_id),
             ),
-            Self::InvalidCanisterId(_) => UserError::new(
-                E::CanisterTrapped,
-                format!("Canister {} provided invalid canister id", canister_id),
-            ),
-            Self::InsufficientCyclesBalance(err) => UserError::new(
-                E::CanisterOutOfCycles,
-                err.to_string(),
-            ),
+            Self::InsufficientCyclesBalance(err) => {
+                UserError::new(E::CanisterOutOfCycles, err.to_string())
+            }
             Self::Cleanup {
                 callback_err,
                 cleanup_err,
@@ -308,67 +278,97 @@ impl HypervisorError {
 
                 UserError::new(
                     callback_user_error.code(), // Use the same error code as the original callback error.
-                    format!("{}\n\ncall_on_cleanup also failed:\n\n{}",
+                    format!(
+                        "{}\n\ncall_on_cleanup also failed:\n\n{}",
                         callback_user_error.description(),
                         cleanup_user_error.description()
-                    )
+                    ),
                 )
             }
             Self::WasmEngineError(err) => UserError::new(
                 E::CanisterWasmEngineError,
                 format!(
-                    "Canister {} encountered a Wasm engine error: {}", canister_id, err
+                    "Canister {} encountered a Wasm engine error: {}",
+                    canister_id, err
                 ),
             ),
             Self::Aborted => {
                 unreachable!("Aborted execution should not be visible to the user.");
-            },
-            Self::SliceOverrun {instructions, limit} => UserError::new(
+            }
+            Self::SliceOverrun {
+                instructions,
+                limit,
+            } => UserError::new(
                 E::CanisterInstructionLimitExceeded,
-                format!("Canister {} attempted to perform \
+                format!(
+                    "Canister {} attempted to perform \
                 a large memory operation that used {} instructions and \
-                exceeded the slice limit {}.", canister_id, instructions, limit),
+                exceeded the slice limit {}.",
+                    canister_id, instructions, limit
+                ),
             ),
             Self::MemoryAccessLimitExceeded(s) => UserError::new(
                 E::CanisterMemoryAccessLimitExceeded,
-                format!("Canister exceeded memory access limits: {}", s)
-
+                format!("Canister exceeded memory access limits: {}", s),
             ),
-            Self::InsufficientCyclesInMemoryGrow { bytes, available, threshold, reveal_top_up } => {
-              let msg = if reveal_top_up {
-                  format!(" At least {} additional cycles are required.", threshold - available)
-              } else {
-                  "".to_string()
-              };
-              UserError::new(
-                E::InsufficientCyclesInMemoryGrow,
-                format!(
-                    "Canister cannot grow memory by {} bytes due to insufficient cycles.{}",
-                    bytes, msg
+            Self::InsufficientCyclesInMemoryGrow {
+                bytes,
+                available,
+                threshold,
+                reveal_top_up,
+            } => {
+                let msg = if reveal_top_up {
+                    format!(
+                        " At least {} additional cycles are required.",
+                        threshold - available
+                    )
+                } else {
+                    "".to_string()
+                };
+                UserError::new(
+                    E::InsufficientCyclesInMemoryGrow,
+                    format!(
+                        "Canister cannot grow memory by {} bytes due to insufficient cycles.{}",
+                        bytes, msg
+                    ),
                 )
-              )
-            },
-            Self::ReservedCyclesLimitExceededInMemoryGrow { bytes, requested, limit } => UserError::new(
-                E::ReservedCyclesLimitExceededInMemoryGrow,
+            }
+            Self::ReservedCyclesLimitExceededInMemoryGrow {
+                bytes,
+                requested,
+                limit,
+            } => {
+                UserError::new(
+                    E::ReservedCyclesLimitExceededInMemoryGrow,
                     format!(
                         "Canister cannot grow memory by {} bytes due to its reserved cycles limit. \
                          The current limit ({}) would be exceeded by {}.",
                         bytes, limit, requested - limit,
                     ),
-            ),
-            Self::InsufficientCyclesInMessageMemoryGrow { bytes, available, threshold, reveal_top_up } => {
-              let msg = if reveal_top_up {
-                  format!(" At least {} additional cycles are required.", threshold - available)
-              } else {
-                  "".to_string()
-              };
-              UserError::new(
-                E::InsufficientCyclesInMessageMemoryGrow,
-                format!(
+                )
+            }
+            Self::InsufficientCyclesInMessageMemoryGrow {
+                bytes,
+                available,
+                threshold,
+                reveal_top_up,
+            } => {
+                let msg = if reveal_top_up {
+                    format!(
+                        " At least {} additional cycles are required.",
+                        threshold - available
+                    )
+                } else {
+                    "".to_string()
+                };
+                UserError::new(
+                    E::InsufficientCyclesInMessageMemoryGrow,
+                    format!(
                     "Canister cannot grow message memory by {} bytes due to insufficient cycles.{}",
                     bytes, msg,
+                ),
                 )
-            )},
+            }
         }
     }
 
@@ -386,10 +386,7 @@ impl HypervisorError {
             HypervisorError::CalledTrap(_) => "CalledTrap",
             HypervisorError::WasmModuleNotFound => "WasmModuleNotFound",
             HypervisorError::OutOfMemory => "OutOfMemory",
-            HypervisorError::CanisterStopped => "CanisterStopped",
-            HypervisorError::InsufficientCyclesInCall { .. } => "InsufficientCyclesInCall",
             HypervisorError::InvalidPrincipalId(_) => "InvalidPrincipalId",
-            HypervisorError::InvalidCanisterId(_) => "InvalidCanisterId",
             HypervisorError::MessageRejected => "MessageRejected",
             HypervisorError::InsufficientCyclesBalance { .. } => "InsufficientCyclesBalance",
             HypervisorError::Cleanup { .. } => "Cleanup",

rs/replicated_state/src/canister_state/system_state/call_context_manager.rs

@@ -82,14 +82,12 @@ impl CallContext {
     /// Updates the available cycles in the `CallContext` based on how much
     /// cycles the canister requested to keep.
     ///
-    /// Returns a `CallContextError::InsufficientCyclesInCall` if `cycles` is
-    /// more than what's available in the call context.
-    pub fn withdraw_cycles(&mut self, cycles: Cycles) -> Result<(), CallContextError> {
+    /// Returns an error if `cycles` is more than what's available in the call
+    /// context.
+    #[allow(clippy::result_unit_err)]
+    pub fn withdraw_cycles(&mut self, cycles: Cycles) -> Result<(), ()> {
         if self.available_cycles < cycles {
-            return Err(CallContextError::InsufficientCyclesInCall {
-                available: self.available_cycles,
-                requested: cycles,
-            });
+            return Err(());
         }
         self.available_cycles -= cycles;
         Ok(())
@@ -173,28 +171,6 @@ impl TryFrom<pb::CallContext> for CallContext {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum CallContextError {
-    InsufficientCyclesInCall {
-        available: Cycles,
-        requested: Cycles,
-    },
-}
-
-impl From<CallContextError> for HypervisorError {
-    fn from(val: CallContextError) -> Self {
-        match val {
-            CallContextError::InsufficientCyclesInCall {
-                available,
-                requested,
-            } => HypervisorError::InsufficientCyclesInCall {
-                available,
-                requested,
-            },
-        }
-    }
-}
-
 /// The action the caller of `CallContext.on_canister_result` should take.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum CallContextAction {

rs/replicated_state/src/canister_state/system_state/call_context_manager/tests.rs

@@ -278,10 +278,7 @@ fn withdraw_cycles_fails_when_not_enough_available_cycles() {
         ccm.call_context_mut(cc_id)
             .unwrap()
             .withdraw_cycles(Cycles::new(40)),
-        Err(CallContextError::InsufficientCyclesInCall {
-            available: Cycles::new(30),
-            requested: Cycles::new(40),
-        })
+        Err(())
     );
 }
 

rs/system_api/src/sandbox_safe_system_state.rs

@@ -314,7 +314,7 @@ impl SystemStateChanges {
                     .ok_or_else(|| {
                         Self::error("Canister accepted cycles from invalid call context")
                     })?;
-                call_context.withdraw_cycles(*amount_taken).map_err(|_| {
+                call_context.withdraw_cycles(*amount_taken).map_err(|()| {
                     Self::error("Canister accepted more cycles than available from call context")
                 })?;
                 if (*amount_taken).get() > LOG_CANISTER_OPERATION_CYCLES_THRESHOLD {