Constant error messages (#535)

* Added errors module and changed json errors

* Set engine module errors as consts

* Set connector module errors as consts

* deposit_event const errors

* extend const errors msgs

engine/src/connector.rs

@@ -725,13 +725,14 @@ pub fn get_metadata<I: IO>(io: &I) -> Option<FungibleTokenMetadata> {
 }
 
 pub mod error {
+    use crate::errors;
     use aurora_engine_types::types::address::error::AddressError;
     use aurora_engine_types::types::balance::error::BalanceOverflowError;
 
     use crate::deposit_event::error::ParseOnTransferMessageError;
     use crate::{deposit_event, fungible_token};
 
-    const PROOF_EXIST: &[u8; 15] = b"ERR_PROOF_EXIST";
+    const PROOF_EXIST: &[u8; 15] = errors::ERR_PROOF_EXIST;
 
     #[cfg_attr(not(target_arch = "wasm32"), derive(Debug))]
     pub enum StorageReadError {
@@ -742,8 +743,8 @@ pub mod error {
     impl AsRef<[u8]> for StorageReadError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::KeyNotFound => b"ERR_CONNECTOR_STORAGE_KEY_NOT_FOUND",
-                Self::BorshDeserialize => b"ERR_FAILED_DESERIALIZE_CONNECTOR_DATA",
+                Self::KeyNotFound => errors::ERR_CONNECTOR_STORAGE_KEY_NOT_FOUND,
+                Self::BorshDeserialize => errors::ERR_FAILED_DESERIALIZE_CONNECTOR_DATA,
             }
         }
     }
@@ -764,7 +765,7 @@ pub mod error {
                 Self::Paused => crate::admin_controlled::ERR_PAUSED.as_bytes(),
                 Self::ProofParseFailed => super::ERR_FAILED_PARSE.as_bytes(),
                 Self::EventParseFailed(e) => e.as_ref(),
-                Self::CustodianAddressMismatch => b"ERR_WRONG_EVENT_ADDRESS",
+                Self::CustodianAddressMismatch => errors::ERR_WRONG_EVENT_ADDRESS,
                 Self::InsufficientAmountForFee => super::ERR_NOT_ENOUGH_BALANCE_FOR_FEE.as_bytes(),
                 Self::InvalidAddress(e) => e.as_ref(),
             }
@@ -871,7 +872,7 @@ pub mod error {
     impl AsRef<[u8]> for InitContractError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::AlreadyInitialized => b"ERR_CONTRACT_INITIALIZED",
+                Self::AlreadyInitialized => errors::ERR_CONTRACT_INITIALIZED,
                 Self::InvalidCustodianAddress(e) => e.as_ref(),
             }
         }

engine/src/deposit_event.rs

@@ -303,6 +303,7 @@ impl DepositedEvent {
 
 pub mod error {
     use super::*;
+    use crate::errors;
 
     #[derive(Debug)]
     pub enum DecodeError {
@@ -312,8 +313,8 @@ pub mod error {
     impl AsRef<[u8]> for DecodeError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::RlpFailed => b"ERR_RLP_FAILED",
-                Self::SchemaMismatch => b"ERR_PARSE_DEPOSIT_EVENT",
+                Self::RlpFailed => errors::ERR_RLP_FAILED,
+                Self::SchemaMismatch => errors::ERR_PARSE_DEPOSIT_EVENT,
             }
         }
     }
@@ -329,8 +330,8 @@ pub mod error {
     impl AsRef<[u8]> for ParseEventMessageError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::TooManyParts => b"ERR_INVALID_EVENT_MESSAGE_FORMAT",
-                Self::InvalidAccount => b"ERR_INVALID_ACCOUNT_ID",
+                Self::TooManyParts => errors::ERR_INVALID_EVENT_MESSAGE_FORMAT,
+                Self::InvalidAccount => errors::ERR_INVALID_ACCOUNT_ID,
                 Self::EthAddressValidationError(e) => e.as_ref(),
                 Self::ParseMessageError(e) => e.as_ref(),
             }
@@ -356,11 +357,11 @@ pub mod error {
         fn as_ref(&self) -> &[u8] {
             match self {
                 Self::LogParseFailed(e) => e.as_ref(),
-                Self::InvalidSender => b"ERR_INVALID_SENDER",
-                Self::InvalidAmount => b"ERR_INVALID_AMOUNT",
-                Self::InvalidFee => b"ERR_INVALID_FEE",
+                Self::InvalidSender => errors::ERR_INVALID_SENDER,
+                Self::InvalidAmount => errors::ERR_INVALID_AMOUNT,
+                Self::InvalidFee => errors::ERR_INVALID_FEE,
                 Self::MessageParseFailed(e) => e.as_ref(),
-                Self::OverflowNumber => b"ERR_OVERFLOW_NUMBER",
+                Self::OverflowNumber => errors::ERR_OVERFLOW_NUMBER,
             }
         }
     }
@@ -377,11 +378,11 @@ pub mod error {
     impl AsRef<[u8]> for ParseOnTransferMessageError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::TooManyParts => b"ERR_INVALID_ON_TRANSFER_MESSAGE_FORMAT",
-                Self::InvalidHexData => b"ERR_INVALID_ON_TRANSFER_MESSAGE_HEX",
-                Self::WrongMessageFormat => b"ERR_INVALID_ON_TRANSFER_MESSAGE_DATA",
-                Self::InvalidAccount => b"ERR_INVALID_ACCOUNT_ID",
-                Self::OverflowNumber => b"ERR_OVERFLOW_NUMBER",
+                Self::TooManyParts => errors::ERR_INVALID_ON_TRANSFER_MESSAGE_FORMAT,
+                Self::InvalidHexData => errors::ERR_INVALID_ON_TRANSFER_MESSAGE_HEX,
+                Self::WrongMessageFormat => errors::ERR_INVALID_ON_TRANSFER_MESSAGE_DATA,
+                Self::InvalidAccount => errors::ERR_INVALID_ACCOUNT_ID,
+                Self::OverflowNumber => errors::ERR_OVERFLOW_NUMBER,
             }
         }
     }

engine/src/engine.rs

@@ -5,6 +5,7 @@ use evm::executor;
 use evm::{Config, CreateScheme, ExitError, ExitFatal, ExitReason};
 
 use crate::connector::EthConnectorContract;
+use crate::errors;
 use crate::map::BijectionMap;
 use aurora_engine_sdk::caching::FullCache;
 use aurora_engine_sdk::env::Env;
@@ -114,31 +115,31 @@ impl EngineErrorKind {
     pub fn as_bytes(&self) -> &[u8] {
         use EngineErrorKind::*;
         match self {
-            EvmError(ExitError::StackUnderflow) => b"ERR_STACK_UNDERFLOW",
-            EvmError(ExitError::StackOverflow) => b"ERR_STACK_OVERFLOW",
-            EvmError(ExitError::InvalidJump) => b"ERR_INVALID_JUMP",
-            EvmError(ExitError::InvalidRange) => b"ERR_INVALID_RANGE",
-            EvmError(ExitError::DesignatedInvalid) => b"ERR_DESIGNATED_INVALID",
-            EvmError(ExitError::CallTooDeep) => b"ERR_CALL_TOO_DEEP",
-            EvmError(ExitError::CreateCollision) => b"ERR_CREATE_COLLISION",
-            EvmError(ExitError::CreateContractLimit) => b"ERR_CREATE_CONTRACT_LIMIT",
-            EvmError(ExitError::OutOfOffset) => b"ERR_OUT_OF_OFFSET",
-            EvmError(ExitError::OutOfGas) => b"ERR_OUT_OF_GAS",
-            EvmError(ExitError::OutOfFund) => b"ERR_OUT_OF_FUND",
+            EvmError(ExitError::StackUnderflow) => errors::ERR_STACK_UNDERFLOW,
+            EvmError(ExitError::StackOverflow) => errors::ERR_STACK_OVERFLOW,
+            EvmError(ExitError::InvalidJump) => errors::ERR_INVALID_JUMP,
+            EvmError(ExitError::InvalidRange) => errors::ERR_INVALID_RANGE,
+            EvmError(ExitError::DesignatedInvalid) => errors::ERR_DESIGNATED_INVALID,
+            EvmError(ExitError::CallTooDeep) => errors::ERR_CALL_TOO_DEEP,
+            EvmError(ExitError::CreateCollision) => errors::ERR_CREATE_COLLISION,
+            EvmError(ExitError::CreateContractLimit) => errors::ERR_CREATE_CONTRACT_LIMIT,
+            EvmError(ExitError::OutOfOffset) => errors::ERR_OUT_OF_OFFSET,
+            EvmError(ExitError::OutOfGas) => errors::ERR_OUT_OF_GAS,
+            EvmError(ExitError::OutOfFund) => errors::ERR_OUT_OF_FUND,
             EvmError(ExitError::Other(m)) => m.as_bytes(),
             EvmError(_) => unreachable!(), // unused misc
-            EvmFatal(ExitFatal::NotSupported) => b"ERR_NOT_SUPPORTED",
-            EvmFatal(ExitFatal::UnhandledInterrupt) => b"ERR_UNHANDLED_INTERRUPT",
+            EvmFatal(ExitFatal::NotSupported) => errors::ERR_NOT_SUPPORTED,
+            EvmFatal(ExitFatal::UnhandledInterrupt) => errors::ERR_UNHANDLED_INTERRUPT,
             EvmFatal(ExitFatal::Other(m)) => m.as_bytes(),
             EvmFatal(_) => unreachable!(), // unused misc
-            IncorrectNonce => b"ERR_INCORRECT_NONCE",
+            IncorrectNonce => errors::ERR_INCORRECT_NONCE,
             FailedTransactionParse(e) => e.as_ref(),
-            InvalidChainId => b"ERR_INVALID_CHAIN_ID",
-            InvalidSignature => b"ERR_INVALID_ECDSA_SIGNATURE",
-            IntrinsicGasNotMet => b"ERR_INTRINSIC_GAS",
-            MaxPriorityGasFeeTooLarge => b"ERR_MAX_PRIORITY_FEE_GREATER",
+            InvalidChainId => errors::ERR_INVALID_CHAIN_ID,
+            InvalidSignature => errors::ERR_INVALID_ECDSA_SIGNATURE,
+            IntrinsicGasNotMet => errors::ERR_INTRINSIC_GAS,
+            MaxPriorityGasFeeTooLarge => errors::ERR_MAX_PRIORITY_FEE_GREATER,
             GasPayment(e) => e.as_ref(),
-            GasOverflow => b"ERR_GAS_OVERFLOW",
+            GasOverflow => errors::ERR_GAS_OVERFLOW,
         }
     }
 }
@@ -190,7 +191,7 @@ pub struct BalanceOverflow;
 
 impl AsRef<[u8]> for BalanceOverflow {
     fn as_ref(&self) -> &[u8] {
-        b"ERR_BALANCE_OVERFLOW"
+        errors::ERR_BALANCE_OVERFLOW
     }
 }
 
@@ -210,8 +211,8 @@ impl AsRef<[u8]> for GasPaymentError {
     fn as_ref(&self) -> &[u8] {
         match self {
             Self::BalanceOverflow(overflow) => overflow.as_ref(),
-            Self::EthAmountOverflow => b"ERR_GAS_ETH_AMOUNT_OVERFLOW",
-            Self::OutOfFund => b"ERR_OUT_OF_FUND",
+            Self::EthAmountOverflow => errors::ERR_GAS_ETH_AMOUNT_OVERFLOW,
+            Self::OutOfFund => errors::ERR_OUT_OF_FUND,
         }
     }
 }
@@ -267,7 +268,7 @@ pub struct AddressParseError;
 
 impl AsRef<[u8]> for AddressParseError {
     fn as_ref(&self) -> &[u8] {
-        b"ERR_PARSE_ADDRESS"
+        errors::ERR_PARSE_ADDRESS
     }
 }
 
@@ -340,8 +341,8 @@ pub enum EngineStateError {
 impl AsRef<[u8]> for EngineStateError {
     fn as_ref(&self) -> &[u8] {
         match self {
-            Self::NotFound => b"ERR_STATE_NOT_FOUND",
-            Self::DeserializationFailed => b"ERR_STATE_CORRUPTED",
+            Self::NotFound => errors::ERR_STATE_NOT_FOUND,
+            Self::DeserializationFailed => errors::ERR_STATE_CORRUPTED,
         }
     }
 }

engine/src/errors.rs

@@ -0,0 +1,88 @@
+pub const ERR_NOT_A_JSON_TYPE: &[u8; 19] = b"ERR_NOT_A_JSON_TYPE";
+pub const ERR_JSON_MISSING_VALUE: &[u8; 22] = b"ERR_JSON_MISSING_VALUE";
+pub const ERR_FAILED_PARSE_U8: &[u8; 19] = b"ERR_FAILED_PARSE_U8";
+pub const ERR_FAILED_PARSE_U64: &[u8; 20] = b"ERR_FAILED_PARSE_U64";
+pub const ERR_FAILED_PARSE_U128: &[u8; 21] = b"ERR_FAILED_PARSE_U128";
+pub const ERR_FAILED_PARSE_BOOL: &[u8; 21] = b"ERR_FAILED_PARSE_BOOL";
+pub const ERR_FAILED_PARSE_STRING: &[u8; 23] = b"ERR_FAILED_PARSE_STRING";
+pub const ERR_FAILED_PARSE_ARRAY: &[u8; 22] = b"ERR_FAILED_PARSE_ARRAY";
+pub const ERR_EXPECTED_STRING_GOT_NUMBER: &[u8; 30] = b"ERR_EXPECTED_STRING_GOT_NUMBER";
+pub const ERR_OUT_OF_RANGE_U8: &[u8; 19] = b"ERR_OUT_OF_RANGE_U8";
+pub const ERR_OUT_OF_RANGE_U128: &[u8; 21] = b"ERR_OUT_OF_RANGE_U128";
+
+pub const ERR_PROMISE_COUNT: &[u8; 17] = b"ERR_PROMISE_COUNT";
+pub const ERR_REFUND_FAILURE: &[u8; 18] = b"ERR_REFUND_FAILURE";
+pub const ERR_NOT_ALLOWED_TOO_EARLY: &[u8; 25] = b"ERR_NOT_ALLOWED:TOO_EARLY";
+pub const ERR_PROMISE_FAILED: &[u8; 18] = b"ERR_PROMISE_FAILED";
+pub const ERR_VERIFY_PROOF: &[u8; 16] = b"ERR_VERIFY_PROOF";
+pub const ERR_INVALID_UPGRADE: &[u8; 19] = b"ERR_INVALID_UPGRADE";
+pub const ERR_NO_UPGRADE: &[u8; 14] = b"ERR_NO_UPGRADE";
+pub const ERR_NOT_ALLOWED: &[u8; 15] = b"ERR_NOT_ALLOWED";
+
+pub const ERR_SERIALIZE: &str = "ERR_SERIALIZE";
+pub const ERR_PROMISE_ENCODING: &str = "ERR_PROMISE_ENCODING";
+pub const ERR_ARGS: &str = "ERR_ARGS";
+
+pub const ERR_BORSH_DESERIALIZE: &str = "ERR_BORSH_DESERIALIZE";
+pub const ERR_META_TX_PARSE: &str = "ERR_META_TX_PARSE";
+
+pub const ERR_STACK_UNDERFLOW: &[u8; 19] = b"ERR_STACK_UNDERFLOW";
+pub const ERR_STACK_OVERFLOW: &[u8; 18] = b"ERR_STACK_OVERFLOW";
+pub const ERR_INVALID_JUMP: &[u8; 16] = b"ERR_INVALID_JUMP";
+pub const ERR_INVALID_RANGE: &[u8; 17] = b"ERR_INVALID_RANGE";
+pub const ERR_DESIGNATED_INVALID: &[u8; 22] = b"ERR_DESIGNATED_INVALID";
+pub const ERR_CALL_TOO_DEEP: &[u8; 17] = b"ERR_CALL_TOO_DEEP";
+pub const ERR_CREATE_COLLISION: &[u8; 20] = b"ERR_CREATE_COLLISION";
+pub const ERR_CREATE_CONTRACT_LIMIT: &[u8; 25] = b"ERR_CREATE_CONTRACT_LIMIT";
+pub const ERR_OUT_OF_OFFSET: &[u8; 17] = b"ERR_OUT_OF_OFFSET";
+pub const ERR_OUT_OF_GAS: &[u8; 14] = b"ERR_OUT_OF_GAS";
+pub const ERR_OUT_OF_FUND: &[u8; 15] = b"ERR_OUT_OF_FUND";
+pub const ERR_NOT_SUPPORTED: &[u8; 17] = b"ERR_NOT_SUPPORTED";
+pub const ERR_UNHANDLED_INTERRUPT: &[u8; 23] = b"ERR_UNHANDLED_INTERRUPT";
+pub const ERR_INCORRECT_NONCE: &[u8; 19] = b"ERR_INCORRECT_NONCE";
+pub const ERR_INVALID_CHAIN_ID: &[u8; 20] = b"ERR_INVALID_CHAIN_ID";
+pub const ERR_INVALID_ECDSA_SIGNATURE: &[u8; 27] = b"ERR_INVALID_ECDSA_SIGNATURE";
+pub const ERR_INTRINSIC_GAS: &[u8; 17] = b"ERR_INTRINSIC_GAS";
+pub const ERR_MAX_PRIORITY_FEE_GREATER: &[u8; 28] = b"ERR_MAX_PRIORITY_FEE_GREATER";
+pub const ERR_GAS_OVERFLOW: &[u8; 16] = b"ERR_GAS_OVERFLOW";
+pub const ERR_BALANCE_OVERFLOW: &[u8; 20] = b"ERR_BALANCE_OVERFLOW";
+pub const ERR_GAS_ETH_AMOUNT_OVERFLOW: &[u8; 27] = b"ERR_GAS_ETH_AMOUNT_OVERFLOW";
+pub const ERR_PARSE_ADDRESS: &[u8; 17] = b"ERR_PARSE_ADDRESS";
+pub const ERR_STATE_NOT_FOUND: &[u8; 19] = b"ERR_STATE_NOT_FOUND";
+pub const ERR_STATE_CORRUPTED: &[u8; 19] = b"ERR_STATE_CORRUPTED";
+
+pub const ERR_CONNECTOR_STORAGE_KEY_NOT_FOUND: &[u8; 35] = b"ERR_CONNECTOR_STORAGE_KEY_NOT_FOUND";
+pub const ERR_FAILED_DESERIALIZE_CONNECTOR_DATA: &[u8; 37] =
+    b"ERR_FAILED_DESERIALIZE_CONNECTOR_DATA";
+pub const ERR_PROOF_EXIST: &[u8; 15] = b"ERR_PROOF_EXIST";
+pub const ERR_WRONG_EVENT_ADDRESS: &[u8; 23] = b"ERR_WRONG_EVENT_ADDRESS";
+pub const ERR_CONTRACT_INITIALIZED: &[u8; 24] = b"ERR_CONTRACT_INITIALIZED";
+
+pub const ERR_RLP_FAILED: &[u8; 14] = b"ERR_RLP_FAILED";
+pub const ERR_PARSE_DEPOSIT_EVENT: &[u8; 23] = b"ERR_PARSE_DEPOSIT_EVENT";
+pub const ERR_INVALID_EVENT_MESSAGE_FORMAT: &[u8; 32] = b"ERR_INVALID_EVENT_MESSAGE_FORMAT";
+pub const ERR_INVALID_SENDER: &[u8; 18] = b"ERR_INVALID_SENDER";
+pub const ERR_INVALID_AMOUNT: &[u8; 18] = b"ERR_INVALID_AMOUNT";
+pub const ERR_INVALID_FEE: &[u8; 15] = b"ERR_INVALID_FEE";
+pub const ERR_INVALID_ON_TRANSFER_MESSAGE_FORMAT: &[u8; 38] =
+    b"ERR_INVALID_ON_TRANSFER_MESSAGE_FORMAT";
+pub const ERR_INVALID_ON_TRANSFER_MESSAGE_HEX: &[u8; 35] = b"ERR_INVALID_ON_TRANSFER_MESSAGE_HEX";
+pub const ERR_INVALID_ON_TRANSFER_MESSAGE_DATA: &[u8; 36] = b"ERR_INVALID_ON_TRANSFER_MESSAGE_DATA";
+pub const ERR_INVALID_ACCOUNT_ID: &[u8; 22] = b"ERR_INVALID_ACCOUNT_ID";
+pub const ERR_OVERFLOW_NUMBER: &[u8; 19] = b"ERR_OVERFLOW_NUMBER";
+
+pub const ERR_TOTAL_SUPPLY_OVERFLOW: &[u8; 25] = b"ERR_TOTAL_SUPPLY_OVERFLOW";
+pub const ERR_NOT_ENOUGH_BALANCE: &[u8; 22] = b"ERR_NOT_ENOUGH_BALANCE";
+pub const ERR_TOTAL_SUPPLY_UNDERFLOW: &[u8; 26] = b"ERR_TOTAL_SUPPLY_UNDERFLOW";
+pub const ERR_ZERO_AMOUNT: &[u8; 15] = b"ERR_ZERO_AMOUNT";
+pub const ERR_SENDER_EQUALS_RECEIVER: &[u8; 26] = b"ERR_SENDER_EQUALS_RECEIVER";
+pub const ERR_ACCOUNT_NOT_REGISTERED: &[u8; 26] = b"ERR_ACCOUNT_NOT_REGISTERED";
+pub const ERR_NO_AVAILABLE_BALANCE: &[u8; 24] = b"ERR_NO_AVAILABLE_BALANCE";
+pub const ERR_ATTACHED_DEPOSIT_NOT_ENOUGH: &[u8; 31] = b"ERR_ATTACHED_DEPOSIT_NOT_ENOUGH";
+pub const ERR_FAILED_UNREGISTER_ACCOUNT_POSITIVE_BALANCE: &[u8; 46] =
+    b"ERR_FAILED_UNREGISTER_ACCOUNT_POSITIVE_BALANCE";
+
+pub const ERR_ACCOUNTS_COUNTER_OVERFLOW: &str = "ERR_ACCOUNTS_COUNTER_OVERFLOW";
+
+pub const ERR_REVERT: &[u8; 10] = b"ERR_REVERT";
+pub const ERR_OUT_OF_FUNDS: &[u8; 16] = b"ERR_OUT_OF_FUNDS";

engine/src/fungible_token.rs

@@ -541,7 +541,7 @@ impl<I: IO + Copy> FungibleTokenOps<I> {
                 .read_u64(&key)
                 .unwrap_or(0)
                 .checked_add(1)
-                .expect("ERR_ACCOUNTS_COUNTER_OVERFLOW");
+                .expect(crate::errors::ERR_ACCOUNTS_COUNTER_OVERFLOW);
             self.io.write_storage(&key, &accounts_counter.to_le_bytes());
         }
         self.io
@@ -589,14 +589,15 @@ impl<I: IO + Copy> FungibleTokenOps<I> {
 }
 
 pub mod error {
+    use crate::errors;
     use crate::prelude::types::balance::error::BalanceOverflowError;
 
-    const TOTAL_SUPPLY_OVERFLOW: &[u8; 25] = b"ERR_TOTAL_SUPPLY_OVERFLOW";
-    const BALANCE_OVERFLOW: &[u8; 20] = b"ERR_BALANCE_OVERFLOW";
-    const NOT_ENOUGH_BALANCE: &[u8; 22] = b"ERR_NOT_ENOUGH_BALANCE";
-    const TOTAL_SUPPLY_UNDERFLOW: &[u8; 26] = b"ERR_TOTAL_SUPPLY_UNDERFLOW";
-    const ZERO_AMOUNT: &[u8; 15] = b"ERR_ZERO_AMOUNT";
-    const SELF_TRANSFER: &[u8; 26] = b"ERR_SENDER_EQUALS_RECEIVER";
+    const TOTAL_SUPPLY_OVERFLOW: &[u8; 25] = errors::ERR_TOTAL_SUPPLY_OVERFLOW;
+    const BALANCE_OVERFLOW: &[u8; 20] = errors::ERR_BALANCE_OVERFLOW;
+    const NOT_ENOUGH_BALANCE: &[u8; 22] = errors::ERR_NOT_ENOUGH_BALANCE;
+    const TOTAL_SUPPLY_UNDERFLOW: &[u8; 26] = errors::ERR_TOTAL_SUPPLY_UNDERFLOW;
+    const ZERO_AMOUNT: &[u8; 15] = errors::ERR_ZERO_AMOUNT;
+    const SELF_TRANSFER: &[u8; 26] = errors::ERR_SENDER_EQUALS_RECEIVER;
 
     #[derive(Debug)]
     pub enum DepositError {
@@ -683,11 +684,11 @@ pub mod error {
     impl AsRef<[u8]> for StorageFundingError {
         fn as_ref(&self) -> &[u8] {
             match self {
-                Self::NotRegistered => b"ERR_ACCOUNT_NOT_REGISTERED",
-                Self::NoAvailableBalance => b"ERR_NO_AVAILABLE_BALANCE",
-                Self::InsufficientDeposit => b"ERR_ATTACHED_DEPOSIT_NOT_ENOUGH",
+                Self::NotRegistered => errors::ERR_ACCOUNT_NOT_REGISTERED,
+                Self::NoAvailableBalance => errors::ERR_NO_AVAILABLE_BALANCE,
+                Self::InsufficientDeposit => errors::ERR_ATTACHED_DEPOSIT_NOT_ENOUGH,
                 Self::UnRegisterPositiveBalance => {
-                    b"ERR_FAILED_UNREGISTER_ACCOUNT_POSITIVE_BALANCE"
+                    errors::ERR_FAILED_UNREGISTER_ACCOUNT_POSITIVE_BALANCE
                 }
             }
         }

engine/src/json.rs

@@ -1,5 +1,6 @@
 use crate::prelude::{BTreeMap, String, Vec};
 
+use crate::errors;
 use core::convert::From;
 use rjson::{Array, Null, Object, Value};
 
@@ -103,15 +104,15 @@ impl JsonValue {
 impl AsRef<[u8]> for JsonError {
     fn as_ref(&self) -> &[u8] {
         match self {
-            Self::NotJsonType => b"ERR_NOT_A_JSON_TYPE",
-            Self::MissingValue => b"ERR_JSON_MISSING_VALUE",
-            Self::InvalidU8 => b"ERR_FAILED_PARSE_U8",
-            Self::InvalidU64 => b"ERR_FAILED_PARSE_U64",
-            Self::InvalidU128 => b"ERR_FAILED_PARSE_U128",
-            Self::InvalidBool => b"ERR_FAILED_PARSE_BOOL",
-            Self::InvalidString => b"ERR_FAILED_PARSE_STRING",
-            Self::InvalidArray => b"ERR_FAILED_PARSE_ARRAY",
-            Self::ExpectedStringGotNumber => b"ERR_EXPECTED_STRING_GOT_NUMBER",
+            Self::NotJsonType => errors::ERR_NOT_A_JSON_TYPE,
+            Self::MissingValue => errors::ERR_JSON_MISSING_VALUE,
+            Self::InvalidU8 => errors::ERR_FAILED_PARSE_U8,
+            Self::InvalidU64 => errors::ERR_FAILED_PARSE_U64,
+            Self::InvalidU128 => errors::ERR_FAILED_PARSE_U128,
+            Self::InvalidBool => errors::ERR_FAILED_PARSE_BOOL,
+            Self::InvalidString => errors::ERR_FAILED_PARSE_STRING,
+            Self::InvalidArray => errors::ERR_FAILED_PARSE_ARRAY,
+            Self::ExpectedStringGotNumber => errors::ERR_EXPECTED_STRING_GOT_NUMBER,
             Self::OutOfRange(err) => err.as_ref(),
         }
     }
@@ -120,8 +121,8 @@ impl AsRef<[u8]> for JsonError {
 impl AsRef<[u8]> for JsonOutOfRangeError {
     fn as_ref(&self) -> &[u8] {
         match self {
-            Self::OutOfRangeU8 => b"ERR_OUT_OF_RANGE_U8",
-            Self::OutOfRangeU128 => b"ERR_OUT_OF_RANGE_U128",
+            Self::OutOfRangeU8 => errors::ERR_OUT_OF_RANGE_U8,
+            Self::OutOfRangeU128 => errors::ERR_OUT_OF_RANGE_U128,
         }
     }
 }