Reorganize the error ids

Author: Seulgi Kim

types/src/errors/history_error.rs

@@ -35,10 +35,10 @@ pub enum Error {
 #[derive(Clone, Copy)]
 #[repr(u8)]
 enum ErrorID {
-    LimitReached = 2,
-    Old = 3,
-    TooCheapToReplace = 6,
-    TxAlreadyImported = 7,
+    LimitReached = 1,
+    Old = 2,
+    TooCheapToReplace = 3,
+    TxAlreadyImported = 4,
 }
 
 impl Encodable for ErrorID {
@@ -51,10 +51,10 @@ impl Decodable for ErrorID {
     fn decode(rlp: &Rlp) -> Result<Self, DecoderError> {
         let tag = rlp.as_val()?;
         match tag {
-            2u8 => Ok(ErrorID::LimitReached),
-            3 => Ok(ErrorID::Old),
-            6 => Ok(ErrorID::TooCheapToReplace),
-            7 => Ok(ErrorID::TxAlreadyImported),
+            1u8 => Ok(ErrorID::LimitReached),
+            2 => Ok(ErrorID::Old),
+            3 => Ok(ErrorID::TooCheapToReplace),
+            4 => Ok(ErrorID::TxAlreadyImported),
             _ => Err(DecoderError::Custom("Unexpected ErrorID Value")),
         }
     }

types/src/errors/runtime_error.rs

@@ -24,7 +24,6 @@ use std::fmt::{Display, Formatter, Result as FormatResult};
 #[derive(Debug, PartialEq, Clone, Eq, Serialize)]
 #[serde(tag = "type", content = "content")]
 pub enum Error {
-    FailedToHandleCustomAction(String),
     /// Sender doesn't have enough funds to pay for this Transaction
     InsufficientBalance {
         address: Address,
@@ -35,18 +34,19 @@ pub enum Error {
     },
     InsufficientPermission,
     /// Returned when transaction seq does not match state seq
-    InvalidSeq(Mismatch<u64>),
     InvalidShardId(ShardId),
     InvalidTransferDestination,
     NewOwnersMustContainSender,
     RegularKeyAlreadyInUse,
     RegularKeyAlreadyInUseAsPlatformAccount,
     /// Tried to use master key even register key is registered
     CannotUseMasterKey,
+    InvalidSeq(Mismatch<u64>),
     NonActiveAccount {
         address: Address,
         name: String,
     },
+    FailedToHandleCustomAction(String),
     SignatureOfInvalidAccount(Address),
     InsufficientStakes(Mismatch<u64>),
     InvalidValidatorIndex {
@@ -58,20 +58,20 @@ pub enum Error {
 #[derive(Clone, Copy)]
 #[repr(u8)]
 enum ErrorID {
-    InsufficientBalance = 8,
-    InsufficientPermission = 9,
-    InvalidShardID = 15,
-    InvalidTransferDestination = 16,
-    NewOwnersMustContainSender = 17,
-    RegularKeyAlreadyInUse = 19,
-    RegularKeyAlreadyInUseAsPlatform = 20,
-    CannotUseMasterKey = 25,
-    InvalidSeq = 28,
-    NonActiveAccount = 30,
-    FailedToHandleCustomAction = 31,
-    SignatureOfInvalid = 32,
-    InsufficientStakes = 33,
-    InvalidValidatorIndex = 34,
+    InsufficientBalance = 1,
+    InsufficientPermission = 2,
+    InvalidShardID = 3,
+    InvalidTransferDestination = 4,
+    NewOwnersMustContainSender = 5,
+    RegularKeyAlreadyInUse = 6,
+    RegularKeyAlreadyInUseAsPlatform = 7,
+    CannotUseMasterKey = 8,
+    InvalidSeq = 9,
+    NonActiveAccount = 10,
+    FailedToHandleCustomAction = 11,
+    SignatureOfInvalid = 12,
+    InsufficientStakes = 13,
+    InvalidValidatorIndex = 14,
 }
 
 impl Encodable for ErrorID {
@@ -84,20 +84,20 @@ impl Decodable for ErrorID {
     fn decode(rlp: &Rlp) -> Result<Self, DecoderError> {
         let tag = rlp.as_val()?;
         match tag {
-            8u8 => Ok(ErrorID::FailedToHandleCustomAction),
-            10 => Ok(ErrorID::InsufficientBalance),
-            11 => Ok(ErrorID::InsufficientPermission),
-            18 => Ok(ErrorID::InvalidSeq),
-            19 => Ok(ErrorID::InvalidShardID),
-            20 => Ok(ErrorID::InvalidTransferDestination),
-            21 => Ok(ErrorID::NewOwnersMustContainSender),
-            23 => Ok(ErrorID::RegularKeyAlreadyInUse),
-            24 => Ok(ErrorID::RegularKeyAlreadyInUseAsPlatform),
-            30 => Ok(ErrorID::CannotUseMasterKey),
-            31 => Ok(ErrorID::NonActiveAccount),
-            32 => Ok(ErrorID::SignatureOfInvalid),
-            33 => Ok(ErrorID::InsufficientStakes),
-            34 => Ok(ErrorID::InvalidValidatorIndex),
+            1u8 => Ok(ErrorID::InsufficientBalance),
+            2 => Ok(ErrorID::InsufficientPermission),
+            3 => Ok(ErrorID::InvalidShardID),
+            4 => Ok(ErrorID::InvalidTransferDestination),
+            5 => Ok(ErrorID::NewOwnersMustContainSender),
+            6 => Ok(ErrorID::RegularKeyAlreadyInUse),
+            7 => Ok(ErrorID::RegularKeyAlreadyInUseAsPlatform),
+            8 => Ok(ErrorID::CannotUseMasterKey),
+            9 => Ok(ErrorID::InvalidSeq),
+            10 => Ok(ErrorID::NonActiveAccount),
+            11 => Ok(ErrorID::FailedToHandleCustomAction),
+            12 => Ok(ErrorID::SignatureOfInvalid),
+            13 => Ok(ErrorID::InsufficientStakes),
+            14 => Ok(ErrorID::InvalidValidatorIndex),
             _ => Err(DecoderError::Custom("Unexpected ActionTag Value")),
         }
     }

types/src/errors/syntax_error.rs

@@ -44,14 +44,14 @@ pub enum Error {
 #[derive(Clone, Copy)]
 #[repr(u8)]
 enum ErrorID {
-    EmptyShardOwners = 4,
-    InsufficientFee = 7,
-    InvalidNetworkID = 11,
-    InvalidApproval = 21,
-    MetadataTooBig = 22,
-    TextContentTooBig = 24,
-    TxIsTooBig = 27,
-    InvalidCustomAction = 32,
+    EmptyShardOwners = 1,
+    InsufficientFee = 2,
+    InvalidNetworkID = 3,
+    InvalidApproval = 4,
+    MetadataTooBig = 5,
+    TextContentTooBig = 6,
+    TxIsTooBig = 7,
+    InvalidCustomAction = 8,
 }
 
 impl Encodable for ErrorID {
@@ -64,14 +64,14 @@ impl Decodable for ErrorID {
     fn decode(rlp: &Rlp) -> Result<Self, DecoderError> {
         let tag = rlp.as_val()?;
         match tag {
-            4u8 => Ok(ErrorID::EmptyShardOwners),
-            7 => Ok(ErrorID::InsufficientFee),
-            11 => Ok(ErrorID::InvalidNetworkID),
-            21 => Ok(ErrorID::InvalidApproval),
-            22 => Ok(ErrorID::MetadataTooBig),
-            24 => Ok(ErrorID::TextContentTooBig),
-            27 => Ok(ErrorID::TxIsTooBig),
-            32 => Ok(ErrorID::InvalidCustomAction),
+            1u8 => Ok(ErrorID::EmptyShardOwners),
+            2 => Ok(ErrorID::InsufficientFee),
+            3 => Ok(ErrorID::InvalidNetworkID),
+            4 => Ok(ErrorID::InvalidApproval),
+            5 => Ok(ErrorID::MetadataTooBig),
+            6 => Ok(ErrorID::TextContentTooBig),
+            7 => Ok(ErrorID::TxIsTooBig),
+            8 => Ok(ErrorID::InvalidCustomAction),
             _ => Err(DecoderError::Custom("Unexpected ErrorID Value")),
         }
     }