move PubkeyError back to solana-pubkey and move ProgramError conversion to solana-pubkey

Author: kevinheavey

Cargo.lock

@@ -68,7 +68,6 @@ members = [
     "program-option",
     "program-pack",
     "pubkey",
-    "pubkey-error",
     "quic-definitions",
     "rent",
     "rent-collector",
@@ -260,7 +259,6 @@ solana-program-memory = { path = "program-memory", version = "2.2.1" }
 solana-program-option = { path = "program-option", version = "2.2.1" }
 solana-program-pack = { path = "program-pack", version = "2.2.1" }
 solana-pubkey = { path = "pubkey", version = "2.2.1", default-features = false }
-solana-pubkey-error = { path = "pubkey-error", version = "1.0.0", default-features = false }
 solana-quic-definitions = { path = "quic-definitions", version = "2.2.1" }
 solana-rent = { path = "rent", version = "2.2.1", default-features = false }
 solana-rent-collector = { path = "rent-collector", version = "2.2.1" }

Cargo.toml

@@ -14,14 +14,12 @@ borsh = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 serde_derive = { workspace = true, optional = true }
 solana-msg = { workspace = true, optional = true }
-solana-pubkey-error = { workspace = true, default-features = false, optional = true }
 
 [features]
 borsh = ["dep:borsh"]
-pubkey-error = ["dep:solana-pubkey-error"]
 solana-msg = ["dep:solana-msg"]
 serde = ["dep:serde", "dep:serde_derive"]
-std = ["solana-pubkey-error?/std"]
+std = []
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

program-error/Cargo.toml

@@ -12,8 +12,6 @@ use core::{convert::TryFrom, fmt};
 use serde_derive::{Deserialize, Serialize};
 #[cfg(feature = "solana-msg")]
 use solana_msg::msg;
-#[cfg(feature = "pubkey-error")]
-use solana_pubkey_error::PubkeyError;
 
 pub type ProgramResult = core::result::Result<(), ProgramError>;
 
@@ -288,17 +286,6 @@ impl From<u64> for ProgramError {
     }
 }
 
-#[cfg(feature = "pubkey-error")]
-impl From<PubkeyError> for ProgramError {
-    fn from(error: PubkeyError) -> Self {
-        match error {
-            PubkeyError::MaxSeedLengthExceeded => Self::MaxSeedLengthExceeded,
-            PubkeyError::InvalidSeeds => Self::InvalidSeeds,
-            PubkeyError::IllegalOwner => Self::IllegalOwner,
-        }
-    }
-}
-
 #[cfg(feature = "borsh")]
 impl From<BorshIoError> for ProgramError {
     fn from(_error: BorshIoError) -> Self {

program-error/src/lib.rs

@@ -29,7 +29,7 @@ solana-frozen-abi = { workspace = true, optional = true, features = [
 solana-frozen-abi-macro = { workspace = true, optional = true, features = [
     "frozen-abi",
 ] }
-solana-pubkey-error = { workspace = true, features = ["num-traits"] }
+solana-program-error = { workspace = true }
 solana-sanitize = { workspace = true }
 
 [target.'cfg(target_os = "solana")'.dependencies]
@@ -73,9 +73,9 @@ frozen-abi = [
     "std",
 ]
 rand = ["dep:rand", "std"]
-serde = ["dep:serde", "dep:serde_derive", "solana-pubkey-error/serde"]
+serde = ["dep:serde", "dep:serde_derive"]
 sha2 = ["dep:solana-sha256-hasher", "solana-sha256-hasher/sha2"]
-std = ["solana-pubkey-error/std"]
+std = []
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]

pubkey-error/Cargo.toml

@@ -12,7 +12,6 @@ use arbitrary::Arbitrary;
 use bytemuck_derive::{Pod, Zeroable};
 #[cfg(feature = "serde")]
 use serde_derive::{Deserialize, Serialize};
-pub use solana_pubkey_error::PubkeyError;
 #[cfg(any(feature = "std", target_arch = "wasm32"))]
 use std::vec::Vec;
 #[cfg(feature = "borsh")]
@@ -29,6 +28,7 @@ use {
     },
     num_traits::{FromPrimitive, ToPrimitive},
     solana_decode_error::DecodeError,
+    solana_program_error::ProgramError,
 };
 #[cfg(target_arch = "wasm32")]
 use {
@@ -55,6 +55,95 @@ const PDA_MARKER: &[u8; 21] = b"ProgramDerivedAddress";
 #[cfg(target_os = "solana")]
 const SUCCESS: u64 = 0;
 
+// Use strum when testing to ensure our FromPrimitive
+// impl is exhaustive
+#[cfg_attr(test, derive(strum_macros::FromRepr, strum_macros::EnumIter))]
+#[cfg_attr(feature = "serde", derive(serde_derive::Serialize))]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PubkeyError {
+    /// Length of the seed is too long for address generation
+    MaxSeedLengthExceeded,
+    InvalidSeeds,
+    IllegalOwner,
+}
+
+impl ToPrimitive for PubkeyError {
+    #[inline]
+    fn to_i64(&self) -> Option<i64> {
+        Some(match *self {
+            PubkeyError::MaxSeedLengthExceeded => PubkeyError::MaxSeedLengthExceeded as i64,
+            PubkeyError::InvalidSeeds => PubkeyError::InvalidSeeds as i64,
+            PubkeyError::IllegalOwner => PubkeyError::IllegalOwner as i64,
+        })
+    }
+    #[inline]
+    fn to_u64(&self) -> Option<u64> {
+        self.to_i64().map(|x| x as u64)
+    }
+}
+
+impl FromPrimitive for PubkeyError {
+    #[inline]
+    fn from_i64(n: i64) -> Option<Self> {
+        if n == PubkeyError::MaxSeedLengthExceeded as i64 {
+            Some(PubkeyError::MaxSeedLengthExceeded)
+        } else if n == PubkeyError::InvalidSeeds as i64 {
+            Some(PubkeyError::InvalidSeeds)
+        } else if n == PubkeyError::IllegalOwner as i64 {
+            Some(PubkeyError::IllegalOwner)
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn from_u64(n: u64) -> Option<Self> {
+        Self::from_i64(n as i64)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for PubkeyError {}
+
+impl fmt::Display for PubkeyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            PubkeyError::MaxSeedLengthExceeded => {
+                f.write_str("Length of the seed is too long for address generation")
+            }
+            PubkeyError::InvalidSeeds => {
+                f.write_str("Provided seeds do not result in a valid address")
+            }
+            PubkeyError::IllegalOwner => f.write_str("Provided owner is not allowed"),
+        }
+    }
+}
+
+impl<T> DecodeError<T> for PubkeyError {
+    fn type_of() -> &'static str {
+        "PubkeyError"
+    }
+}
+impl From<u64> for PubkeyError {
+    fn from(error: u64) -> Self {
+        match error {
+            0 => PubkeyError::MaxSeedLengthExceeded,
+            1 => PubkeyError::InvalidSeeds,
+            2 => PubkeyError::IllegalOwner,
+            _ => panic!("Unsupported PubkeyError"),
+        }
+    }
+}
+
+impl From<PubkeyError> for ProgramError {
+    fn from(error: PubkeyError) -> Self {
+        match error {
+            PubkeyError::MaxSeedLengthExceeded => Self::MaxSeedLengthExceeded,
+            PubkeyError::InvalidSeeds => Self::InvalidSeeds,
+            PubkeyError::IllegalOwner => Self::IllegalOwner,
+        }
+    }
+}
+
 /// The address of a [Solana account][acc].
 ///
 /// Some account addresses are [ed25519] public keys, with corresponding secret
@@ -1296,6 +1385,18 @@ mod tests {
         assert!(pubkey_from_seed_by_marker(&PDA_MARKER[1..]).is_ok());
     }
 
+    #[test]
+    fn test_pubkey_error_from_primitive_exhaustive() {
+        for variant in PubkeyError::iter() {
+            let variant_i64 = variant.clone() as i64;
+            assert_eq!(
+                PubkeyError::from_repr(variant_i64 as usize),
+                PubkeyError::from_i64(variant_i64)
+            );
+            assert_eq!(PubkeyError::from(variant_i64 as u64), variant);
+        }
+    }
+
     #[test]
     fn test_parse_pubkey_error_from_primitive_exhaustive() {
         for variant in ParsePubkeyError::iter() {