Move types to more appropriate files (#10638)

sdk/src/account.rs

@@ -286,3 +286,16 @@ where
         .cloned()
         .collect::<A>()
 }
+
+/// Return the next KeyedAccount or a NotEnoughAccountKeys error
+pub fn next_keyed_account<'a, 'b, I: Iterator<Item = &'a KeyedAccount<'b>>>(
+    iter: &mut I,
+) -> Result<I::Item, InstructionError> {
+    iter.next().ok_or(InstructionError::NotEnoughAccountKeys)
+}
+
+/// Return true if the first keyed_account is executable, used to determine if
+/// the loader should call a program's 'main'
+pub fn is_executable(keyed_accounts: &[KeyedAccount]) -> Result<bool, InstructionError> {
+    Ok(!keyed_accounts.is_empty() && keyed_accounts[0].executable()?)
+}

sdk/src/account_info.rs

@@ -216,3 +216,10 @@ pub fn create_is_signer_account_infos<'a>(
         })
         .collect()
 }
+
+/// Return the next AccountInfo or a NotEnoughAccountKeys error
+pub fn next_account_info<'a, 'b, I: Iterator<Item = &'a AccountInfo<'b>>>(
+    iter: &mut I,
+) -> Result<I::Item, ProgramError> {
+    iter.next().ok_or(ProgramError::NotEnoughAccountKeys)
+}

sdk/src/decode_error.rs

@@ -0,0 +1,38 @@
+use num_traits::FromPrimitive;
+
+/// Allows customer errors to be decoded back to their original enum
+pub trait DecodeError<E> {
+    fn decode_custom_error_to_enum(custom: u32) -> Option<E>
+    where
+        E: FromPrimitive,
+    {
+        E::from_u32(custom)
+    }
+    fn type_of() -> &'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() -> &'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/lib.rs

@@ -13,6 +13,7 @@ pub mod account_utils;
 pub mod bpf_loader;
 pub mod clock;
 pub mod commitment_config;
+pub mod decode_error;
 pub mod entrypoint_native;
 pub mod epoch_info;
 pub mod epoch_schedule;

sdk/src/program_error.rs

@@ -1,4 +1,4 @@
-use crate::{instruction::InstructionError, program_utils::DecodeError};
+use crate::{decode_error::DecodeError, instruction::InstructionError};
 use num_traits::{FromPrimitive, ToPrimitive};
 use std::convert::TryFrom;
 use thiserror::Error;

sdk/src/program_utils.rs

@@ -1,28 +1,4 @@
-use crate::{
-    account::KeyedAccount, account_info::AccountInfo, instruction::InstructionError,
-    program_error::ProgramError,
-};
-use num_traits::FromPrimitive;
-
-/// Return the next KeyedAccount or a NotEnoughAccountKeys error
-pub fn next_keyed_account<'a, 'b, I: Iterator<Item = &'a KeyedAccount<'b>>>(
-    iter: &mut I,
-) -> Result<I::Item, InstructionError> {
-    iter.next().ok_or(InstructionError::NotEnoughAccountKeys)
-}
-
-/// Return the next AccountInfo or a NotEnoughAccountKeys error
-pub fn next_account_info<'a, 'b, I: Iterator<Item = &'a AccountInfo<'b>>>(
-    iter: &mut I,
-) -> Result<I::Item, ProgramError> {
-    iter.next().ok_or(ProgramError::NotEnoughAccountKeys)
-}
-
-/// Return true if the first keyed_account is executable, used to determine if
-/// the loader should call a program's 'main'
-pub fn is_executable(keyed_accounts: &[KeyedAccount]) -> Result<bool, InstructionError> {
-    Ok(!keyed_accounts.is_empty() && keyed_accounts[0].executable()?)
-}
+use crate::instruction::InstructionError;
 
 /// Deserialize with a limit based the maximum amount of data a program can expect to get.
 /// This function should be used in place of direct deserialization to help prevent OOM errors
@@ -36,40 +12,3 @@ where
         .deserialize(instruction_data)
         .map_err(|_| InstructionError::InvalidInstructionData)
 }
-
-/// Allows customer errors to be decoded back to their original enum
-pub trait DecodeError<E> {
-    fn decode_custom_error_to_enum(custom: u32) -> Option<E>
-    where
-        E: FromPrimitive,
-    {
-        E::from_u32(custom)
-    }
-    fn type_of() -> &'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() -> &'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/pubkey.rs

@@ -1,6 +1,6 @@
 use crate::{
+    decode_error::DecodeError,
     hash::{hash, hashv, Hasher},
-    program_utils::DecodeError,
 };
 use num_derive::{FromPrimitive, ToPrimitive};
 #[cfg(not(feature = "program"))]

sdk/src/system_instruction.rs

@@ -1,7 +1,7 @@
 use crate::{
+    decode_error::DecodeError,
     instruction::{AccountMeta, Instruction},
     nonce,
-    program_utils::DecodeError,
     pubkey::Pubkey,
     system_program,
     sysvar::{recent_blockhashes, rent},