Custom error decoder (#3783)

automerge

sdk/src/instruction_processor_utils.rs

@@ -2,6 +2,7 @@ use crate::account::{Account, KeyedAccount};
 use crate::instruction::InstructionError;
 use crate::pubkey::Pubkey;
 use bincode::ErrorKind;
+use num_traits::FromPrimitive;
 
 // All native programs export a symbol named process()
 pub const ENTRYPOINT: &str = "process";
@@ -64,3 +65,39 @@ where
         self.account.set_state(state)
     }
 }
+
+pub trait DecodeError<E> {
+    fn decode_custom_error_to_enum(int: u32) -> Option<E>
+    where
+        E: FromPrimitive,
+    {
+        E::from_u32(int)
+    }
+    fn type_of(&self) -> &'static str;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use num_derive::FromPrimitive;
+
+    #[test]
+    fn test_decode_custom_error_to_enum() {
+        #[derive(Debug, FromPrimitive, PartialEq)]
+        enum TestEnum {
+            A,
+            B,
+            C,
+        }
+        impl<T> DecodeError<T> for TestEnum {
+            fn type_of(&self) -> &'static str {
+                "TestEnum"
+            }
+        }
+        assert_eq!(TestEnum::decode_custom_error_to_enum(0), Some(TestEnum::A));
+        assert_eq!(TestEnum::decode_custom_error_to_enum(1), Some(TestEnum::B));
+        assert_eq!(TestEnum::decode_custom_error_to_enum(2), Some(TestEnum::C));
+        let option: Option<TestEnum> = TestEnum::decode_custom_error_to_enum(3);
+        assert_eq!(option, None);
+    }
+}

sdk/src/system_instruction.rs

@@ -1,14 +1,29 @@
 use crate::instruction::{AccountMeta, Instruction};
+use crate::instruction_processor_utils::DecodeError;
 use crate::pubkey::Pubkey;
 use crate::system_program;
+use num_derive::FromPrimitive;
 
-#[derive(Serialize, Debug, Clone, PartialEq)]
+#[derive(Serialize, Debug, Clone, PartialEq, FromPrimitive)]
 pub enum SystemError {
     AccountAlreadyInUse,
     ResultWithNegativeLamports,
     SourceNotSystemAccount,
 }
 
+impl<T> DecodeError<T> for SystemError {
+    fn type_of(&self) -> &'static str {
+        "SystemError"
+    }
+}
+
+impl std::fmt::Display for SystemError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "error")
+    }
+}
+impl std::error::Error for SystemError {}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub enum SystemInstruction {
     /// Create a new account