errors

contracts/button/Cargo.toml

@@ -38,6 +38,10 @@ std = [
     "ink_primitives/std",
     "ink_storage/std",
     "scale-info/std",
-    "scale/std"
+    "scale/std",
+    "access_control/std",
+    "game_token/std",
+    "ticket_token/std",
+    "openbrush/std",
 ]
 ink-as-dependency = []

contracts/button/errors.rs

@@ -1,3 +1,4 @@
+use access_control::Role;
 use ink_env::Error as InkEnvError;
 use ink_prelude::{format, string::String};
 use openbrush::contracts::psp22::PSP22Error;
@@ -6,82 +7,24 @@ use openbrush::contracts::psp22::PSP22Error;
 #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
 #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
 pub enum GameError {
-    /// Returned if reset is called before the deadline
+    /// Reset has been called before the deadline
     BeforeDeadline,
-    /// Returned if button is pressed after the deadline
+    /// Button has been pressed after the deadline
     AfterDeadline,
-    /// Returned if a call is made from an account with missing access control privileges
-    MissingRole(String),
+    /// Call has been made from an account with missing access control privileges
+    MissingRole(Role),
     /// Returned if a call to another contract has failed
-    ContractCall(String),
+    CrossContractCallFailed(String),
 }
 
 impl From<PSP22Error> for GameError {
     fn from(e: PSP22Error) -> Self {
-        match e {
-            PSP22Error::Custom(message) => GameError::ContractCall(message),
-            PSP22Error::InsufficientBalance => {
-                GameError::ContractCall(String::from("PSP22::InsufficientBalance"))
-            }
-            PSP22Error::InsufficientAllowance => {
-                GameError::ContractCall(String::from("PSP22::InsufficientAllowance"))
-            }
-            PSP22Error::ZeroRecipientAddress => {
-                GameError::ContractCall(String::from("PSP22::ZeroRecipientAddress"))
-            }
-            PSP22Error::ZeroSenderAddress => {
-                GameError::ContractCall(String::from("PSP22::ZeroSenderAddress"))
-            }
-            PSP22Error::SafeTransferCheckFailed(message) => {
-                GameError::ContractCall(format!("PSP22::SafeTransferCheckFailed({})", message))
-            }
-        }
+        GameError::CrossContractCallFailed(format!("{:?}", e))
     }
 }
 
 impl From<InkEnvError> for GameError {
     fn from(e: InkEnvError) -> Self {
-        match e {
-            InkEnvError::Decode(_e) => {
-                GameError::ContractCall(String::from("Contract call failed due to Decode error"))
-            }
-            InkEnvError::CalleeTrapped => GameError::ContractCall(String::from(
-                "Contract call failed due to CalleeTrapped error",
-            )),
-            InkEnvError::CalleeReverted => GameError::ContractCall(String::from(
-                "Contract call failed due to CalleeReverted error",
-            )),
-            InkEnvError::KeyNotFound => GameError::ContractCall(String::from(
-                "Contract call failed due to KeyNotFound error",
-            )),
-            InkEnvError::_BelowSubsistenceThreshold => GameError::ContractCall(String::from(
-                "Contract call failed due to _BelowSubsistenceThreshold error",
-            )),
-            InkEnvError::TransferFailed => GameError::ContractCall(String::from(
-                "Contract call failed due to TransferFailed error",
-            )),
-            InkEnvError::_EndowmentTooLow => GameError::ContractCall(String::from(
-                "Contract call failed due to _EndowmentTooLow error",
-            )),
-            InkEnvError::CodeNotFound => GameError::ContractCall(String::from(
-                "Contract call failed due to CodeNotFound error",
-            )),
-            InkEnvError::NotCallable => GameError::ContractCall(String::from(
-                "Contract call failed due to NotCallable error",
-            )),
-            InkEnvError::Unknown => {
-                GameError::ContractCall(String::from("Contract call failed due to Unknown error"))
-            }
-            InkEnvError::LoggingDisabled => GameError::ContractCall(String::from(
-                "Contract call failed due to LoggingDisabled error",
-            )),
-            InkEnvError::EcdsaRecoveryFailed => GameError::ContractCall(String::from(
-                "Contract call failed due to EcdsaRecoveryFailed error",
-            )),
-            #[cfg(any(feature = "std", test, doc))]
-            InkEnvError::OffChain(_e) => {
-                GameError::ContractCall(String::from("Contract call failed due to OffChain error"))
-            }
-        }
+        GameError::CrossContractCallFailed(format!("Contract call failed due to {:?}", e))
     }
 }

contracts/button/lib.rs

@@ -117,9 +117,12 @@ mod button_game {
                 caller,
                 required_role,
                 |why: InkEnvError| {
-                    GameError::ContractCall(format!("Calling access control has failed: {:?}", why))
+                    GameError::CrossContractCallFailed(format!(
+                        "Calling access control has failed: {:?}",
+                        why
+                    ))
                 },
-                |role: Role| GameError::MissingRole(format!("{:?}", role)),
+                |role: Role| GameError::MissingRole(role),
             );
 
             match role_check {
@@ -171,7 +174,10 @@ mod button_game {
         #[ink(message)]
         pub fn code_hash(&self) -> ButtonResult<Hash> {
             self.env().own_code_hash().map_err(|why| {
-                GameError::ContractCall(format!("Can't retrieve own code hash: {:?}", why))
+                GameError::CrossContractCallFailed(format!(
+                    "Can't retrieve own code hash: {:?}",
+                    why
+                ))
             })
         }
 
@@ -314,9 +320,12 @@ mod button_game {
                 account,
                 role,
                 |why: InkEnvError| {
-                    GameError::ContractCall(format!("Calling access control has failed: {:?}", why))
+                    GameError::CrossContractCallFailed(format!(
+                        "Calling access control has failed: {:?}",
+                        why
+                    ))
                 },
-                |role: Role| GameError::MissingRole(format!("{:?}", role)),
+                |role: Role| GameError::MissingRole(role),
             )
         }