odra_core/
error.rs

1use casper_types::bytesrepr::Error as BytesReprError;
2use casper_types::{CLType, CLValueError};
3use core::any::Any;
4
5use crate::arithmetic::ArithmeticsError;
6use crate::prelude::*;
7use crate::VmError::Serialization;
8
9/// The name of the generic Casper error used in Odra framework.
10/// When we get an error from the Casper VM, we use this name to represent it,
11/// because the Casper VM does not provide a specific error name, but the code
12/// only.
13pub const CASPER_ERROR_GENERIC_NAME: &str = "CasperExecError";
14
15/// General error type in Odra framework
16#[repr(u16)]
17#[derive(Clone, Debug, PartialEq)]
18pub enum OdraError {
19    /// An error that can occur during smart contract execution
20    ExecutionError(ExecutionError),
21    /// An internal virtual machine error
22    VmError(VmError)
23}
24
25impl OdraError {
26    /// Returns the error code.
27    pub fn code(&self) -> u16 {
28        match self {
29            OdraError::ExecutionError(e) => e.code(),
30            OdraError::VmError(_e) => 0
31        }
32    }
33
34    #[cfg(target_arch = "wasm32")]
35    /// Creates a new user error with a given code.
36    pub fn user(code: u16) -> Self {
37        if code >= ExecutionError::UserErrorTooHigh.code() {
38            ExecutionError::UserErrorTooHigh.into()
39        } else {
40            ExecutionError::User(code).into()
41        }
42    }
43
44    #[cfg(not(target_arch = "wasm32"))]
45    /// Creates a new user error with a given code.
46    pub fn user(code: u16, msg: &str) -> Self {
47        if code >= ExecutionError::UserErrorTooHigh.code() {
48            ExecutionError::UserErrorTooHigh.into()
49        } else {
50            ExecutionError::User(UserError {
51                code,
52                message: msg.to_string()
53            })
54            .into()
55        }
56    }
57}
58
59impl From<ArithmeticsError> for ExecutionError {
60    fn from(error: ArithmeticsError) -> Self {
61        match error {
62            ArithmeticsError::AdditionOverflow => Self::AdditionOverflow,
63            ArithmeticsError::SubtractingOverflow => Self::SubtractionOverflow,
64            ArithmeticsError::ConversionError => Self::ConversionError
65        }
66    }
67}
68
69impl From<ArithmeticsError> for OdraError {
70    fn from(error: ArithmeticsError) -> Self {
71        Into::<ExecutionError>::into(error).into()
72    }
73}
74
75impl From<Box<dyn Any + Send>> for OdraError {
76    fn from(_: Box<dyn Any + Send>) -> Self {
77        OdraError::VmError(VmError::Panic)
78    }
79}
80
81impl From<casper_types::bytesrepr::Error> for ExecutionError {
82    fn from(error: casper_types::bytesrepr::Error) -> Self {
83        match error {
84            casper_types::bytesrepr::Error::EarlyEndOfStream => Self::EarlyEndOfStream,
85            casper_types::bytesrepr::Error::Formatting => Self::Formatting,
86            casper_types::bytesrepr::Error::LeftOverBytes => Self::LeftOverBytes,
87            casper_types::bytesrepr::Error::OutOfMemory => Self::OutOfMemory,
88            casper_types::bytesrepr::Error::NotRepresentable => Self::NotRepresentable,
89            casper_types::bytesrepr::Error::ExceededRecursionDepth => Self::ExceededRecursionDepth,
90            _ => Self::Formatting
91        }
92    }
93}
94
95/// An error that can occur during smart contract execution
96///
97/// It is represented by an error code and a human-readable message.
98///
99/// Errors codes 0..32767 are available for the user to define custom error
100/// in smart contracts.
101/// 32768 code is a special code representing a violation of the custom error code space.
102///
103/// The rest of codes 32769..[u16::MAX](u16::MAX), are used internally by the framework.
104#[repr(u16)]
105#[derive(Clone, Debug, PartialEq)]
106pub enum ExecutionError {
107    /// Unwrap error.
108    UnwrapError = 1,
109    /// Something unexpected happened.
110    UnexpectedError = 2,
111    /// Addition overflow
112    AdditionOverflow = 100,
113    /// Subtraction overflow
114    SubtractionOverflow = 101,
115    /// Method does not accept deposit
116    NonPayable = 102,
117    /// Can't transfer tokens to contract.
118    TransferToContract = 103,
119    /// Reentrant call detected
120    ReentrantCall = 104,
121    /// Contract already installed
122    CannotOverrideKeys = 105,
123    /// Unknown constructor
124    UnknownConstructor = 106,
125    /// Native transfer error
126    NativeTransferError = 107,
127    /// Index out of bounds
128    IndexOutOfBounds = 108,
129    /// Tried to construct a zero address.
130    ZeroAddress = 109,
131    /// Address creation failed
132    AddressCreationFailed = 110,
133    /// Early end of stream - deserialization error
134    EarlyEndOfStream = 111,
135    /// Formatting error - deserialization error
136    Formatting = 112,
137    /// Left over bytes - deserialization error
138    LeftOverBytes = 113,
139    /// Out of memory
140    OutOfMemory = 114,
141    /// Not representable
142    NotRepresentable = 115,
143    /// Exceeded recursion depth
144    ExceededRecursionDepth = 116,
145    /// Key not found
146    KeyNotFound = 117,
147    /// Could not deserialize signature
148    CouldNotDeserializeSignature = 118,
149    /// Type mismatch
150    TypeMismatch = 119,
151    /// Could not sign message
152    CouldNotSignMessage = 120,
153    /// Empty dictionary name
154    EmptyDictionaryName = 121,
155    /// Calling a contract with missing entrypoint arguments.
156    MissingArg = 122,
157    /// Reading the address from the storage failed.
158    MissingAddress = 123,
159    /// Out of gas error
160    OutOfGas = 124,
161    /// MainPurse error
162    MainPurseError = 125,
163    /// Conversion error
164    ConversionError = 126,
165    /// Couldn't deploy the contract
166    ContractDeploymentError = 127,
167    /// Couldn't extract caller info
168    CannotExtractCallerInfo = 128,
169    /// Upgrading a contract that is not installed.
170    ContractNotInstalled = 129,
171    /// Upgrading a contract without previous version
172    UpgradingWithoutPreviousVersion = 130,
173    /// Upgrading not a contract
174    UpgradingNotAContract = 131,
175    /// Upgrading a contract with a schema that does not match the previous version.
176    SchemaMismatch = 132,
177    /// Cannot disable a previous version of a contract.
178    CannotDisablePreviousVersion = 133,
179    /// Cannot upgrade a contract without an upgrade function.
180    CannotUpgradeWithoutUpgrade = 134,
181    /// Factory module function should not be called directly.
182    FactoryModuleCall = 135,
183    /// Cannot get an immediate caller
184    CannotGetAnImmediateCaller = 136,
185    /// Maximum code for user errors
186    MaxUserError = 64535,
187    /// User error too high. The code should be in range 0..32767.
188    UserErrorTooHigh = 64536,
189    /// User error
190    #[cfg(target_arch = "wasm32")]
191    User(u16),
192    #[cfg(not(target_arch = "wasm32"))]
193    /// User error
194    User(UserError)
195}
196
197#[cfg(not(target_arch = "wasm32"))]
198#[derive(Debug, Clone)]
199pub struct UserError {
200    code: u16,
201    message: String
202}
203
204#[cfg(not(target_arch = "wasm32"))]
205impl PartialEq for UserError {
206    fn eq(&self, other: &Self) -> bool {
207        if self.message == CASPER_ERROR_GENERIC_NAME || other.message == CASPER_ERROR_GENERIC_NAME {
208            return self.code == other.code;
209        }
210        // Compare both code and message for equality
211        self.code == other.code && self.message == other.message
212    }
213}
214
215impl ExecutionError {
216    /// Returns the error code.
217    pub fn code(&self) -> u16 {
218        unsafe {
219            match self {
220                #[cfg(target_arch = "wasm32")]
221                ExecutionError::User(code) => *code,
222                #[cfg(not(target_arch = "wasm32"))]
223                ExecutionError::User(UserError { code, .. }) => *code,
224                ExecutionError::MaxUserError => 64535,
225                ExecutionError::UserErrorTooHigh => 64536,
226                _ => ExecutionError::UserErrorTooHigh.code() + *(self as *const Self as *const u16)
227            }
228        }
229    }
230}
231
232impl From<ExecutionError> for OdraError {
233    fn from(error: ExecutionError) -> Self {
234        Self::ExecutionError(error)
235    }
236}
237
238/// An internal virtual machine error
239#[derive(Clone, Debug, PartialEq, Eq)]
240pub enum VmError {
241    /// Failed to serialize a value.
242    Serialization,
243    /// Failed to deserialize a value.
244    Deserialization,
245    /// Exceeded the account balance
246    BalanceExceeded,
247    /// Non existing host entrypoint was called.
248    NoSuchMethod(String),
249    /// Accessing a contract with an invalid address.
250    InvalidContractAddress,
251    /// Error calling a host function in a wrong context.
252    InvalidContext,
253    /// Calling a contract with a wrong argument type.
254    TypeMismatch {
255        /// Expected type.
256        expected: CLType,
257        /// Found type.
258        found: CLType
259    },
260    /// Non-specified error with a custom message.
261    Other(String),
262    /// Unspecified error.
263    Panic
264}
265
266/// Error that can occur while operating on a collection.
267pub enum CollectionError {
268    /// The requested index is bigger than the max collection index.
269    IndexOutOfBounds
270}
271
272impl From<CollectionError> for ExecutionError {
273    fn from(error: CollectionError) -> Self {
274        match error {
275            CollectionError::IndexOutOfBounds => Self::IndexOutOfBounds
276        }
277    }
278}
279
280impl From<CollectionError> for OdraError {
281    fn from(error: CollectionError) -> Self {
282        Into::<ExecutionError>::into(error).into()
283    }
284}
285
286/// Error that can occur while operating on an Address.
287#[derive(Clone, Debug, PartialEq)]
288pub enum AddressError {
289    /// Tried to construct a zero address.
290    ZeroAddress,
291    /// Tried to construct an address and failed.
292    AddressCreationError
293}
294
295impl From<AddressError> for ExecutionError {
296    fn from(error: AddressError) -> Self {
297        match error {
298            AddressError::ZeroAddress => Self::ZeroAddress,
299            AddressError::AddressCreationError => Self::AddressCreationFailed
300        }
301    }
302}
303
304impl From<AddressError> for OdraError {
305    fn from(error: AddressError) -> Self {
306        Into::<ExecutionError>::into(error).into()
307    }
308}
309
310/// Event-related errors.
311#[derive(Debug, PartialEq, Eq, PartialOrd)]
312pub enum EventError {
313    /// The type of event is different from expected.
314    UnexpectedType(String),
315    /// Index of the event is out of bounds.
316    IndexOutOfBounds,
317    /// Formatting error while deserializing.
318    Formatting,
319    /// Unexpected error while deserializing.
320    Parsing,
321    /// Could not extract event name.
322    CouldntExtractName,
323    /// Could not extract event data.
324    CouldntExtractEventData,
325    /// Contract doesn't support CES events.
326    ContractDoesntSupportEvents,
327    /// Tried to query event for a non-contract entity.
328    TriedToQueryEventForNonContract
329}
330
331/// Represents the result of a contract call.
332pub type OdraResult<T> = Result<T, OdraError>;
333
334impl From<CLValueError> for OdraError {
335    fn from(error: CLValueError) -> Self {
336        match error {
337            CLValueError::Serialization(_) => OdraError::VmError(Serialization),
338            CLValueError::Type(cl_type_mismatch) => OdraError::VmError(VmError::TypeMismatch {
339                expected: cl_type_mismatch.expected.clone(),
340                found: cl_type_mismatch.found.clone()
341            })
342        }
343    }
344}
345
346impl From<BytesReprError> for OdraError {
347    fn from(error: BytesReprError) -> Self {
348        match error {
349            BytesReprError::EarlyEndOfStream => ExecutionError::EarlyEndOfStream,
350            BytesReprError::Formatting => ExecutionError::Formatting,
351            BytesReprError::LeftOverBytes => ExecutionError::LeftOverBytes,
352            BytesReprError::OutOfMemory => ExecutionError::OutOfMemory,
353            BytesReprError::NotRepresentable => ExecutionError::NotRepresentable,
354            BytesReprError::ExceededRecursionDepth => ExecutionError::ExceededRecursionDepth,
355            _ => ExecutionError::Formatting
356        }
357        .into()
358    }
359}
360
361impl From<anyhow::Error> for OdraError {
362    fn from(value: anyhow::Error) -> Self {
363        OdraError::VmError(VmError::Other(value.to_string()))
364    }
365}
odra_core/error.rs

odra_core/
error.rs
