Extract precompile-error crate (solana-labs#2300)

* extract precompile-error crate

* update PrecompileError usage

* remove thiserror from precompile-error crate

* fmt

* remove num-derive

* fix imports after rebase

* sort deps

* sort deps

* fmt

Cargo.toml

@@ -119,6 +119,7 @@ members = [
     "sdk/native-token",
     "sdk/package-metadata",
     "sdk/package-metadata-macro",
+    "sdk/precompile-error",
     "sdk/program",
     "sdk/program-entrypoint",
     "sdk/program-error",
@@ -444,6 +445,7 @@ solana-package-metadata-macro = { path = "sdk/package-metadata-macro", version =
 solana-perf = { path = "perf", version = "=2.1.0" }
 solana-poh = { path = "poh", version = "=2.1.0" }
 solana-poseidon = { path = "poseidon", version = "=2.1.0" }
+solana-precompile-error = { path = "sdk/precompile-error", version = "=2.1.0" }
 solana-program = { path = "sdk/program", version = "=2.1.0", default-features = false }
 solana-program-error = { path = "sdk/program-error", version = "=2.1.0" }
 solana-program-memory = { path = "sdk/program-memory", version = "=2.1.0" }

sdk/Cargo.toml

@@ -34,6 +34,7 @@ full = [
     "sha3",
     "digest",
     "solana-pubkey/rand",
+    "dep:solana-precompile-error"
 ]
 borsh = ["dep:borsh", "solana-program/borsh", "solana-secp256k1-recover/borsh"]
 dev-context-only-utils = ["qualifier_attr", "solana-account/dev-context-only-utils"]
@@ -96,7 +97,9 @@ solana-frozen-abi = { workspace = true, optional = true, features = [
 solana-frozen-abi-macro = { workspace = true, optional = true, features = [
     "frozen-abi",
 ] }
+solana-instruction = { workspace = true }
 solana-native-token = { workspace = true }
+solana-precompile-error = { workspace = true, optional = true }
 solana-program = { workspace = true }
 solana-program-memory = { workspace = true }
 solana-pubkey = { workspace = true, default-features = false, features = ["std"] }

sdk/precompile-error/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "solana-precompile-error"
+description = "Solana PrecompileError type"
+documentation = "https://docs.rs/solana-precompile-error"
+version = { workspace = true }
+authors = { workspace = true }
+repository = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+edition = { workspace = true }
+
+[dependencies]
+num-traits = { workspace = true }
+solana-decode-error = { workspace = true }
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

sdk/precompile-error/src/lib.rs

@@ -0,0 +1,76 @@
+/// Precompile errors
+use {core::fmt, solana_decode_error::DecodeError};
+
+/// Precompile errors
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PrecompileError {
+    InvalidPublicKey,
+    InvalidRecoveryId,
+    InvalidSignature,
+    InvalidDataOffsets,
+    InvalidInstructionDataSize,
+}
+
+impl num_traits::FromPrimitive for PrecompileError {
+    #[inline]
+    fn from_i64(n: i64) -> Option<Self> {
+        if n == PrecompileError::InvalidPublicKey as i64 {
+            Some(PrecompileError::InvalidPublicKey)
+        } else if n == PrecompileError::InvalidRecoveryId as i64 {
+            Some(PrecompileError::InvalidRecoveryId)
+        } else if n == PrecompileError::InvalidSignature as i64 {
+            Some(PrecompileError::InvalidSignature)
+        } else if n == PrecompileError::InvalidDataOffsets as i64 {
+            Some(PrecompileError::InvalidDataOffsets)
+        } else if n == PrecompileError::InvalidInstructionDataSize as i64 {
+            Some(PrecompileError::InvalidInstructionDataSize)
+        } else {
+            None
+        }
+    }
+    #[inline]
+    fn from_u64(n: u64) -> Option<Self> {
+        Self::from_i64(n as i64)
+    }
+}
+
+impl num_traits::ToPrimitive for PrecompileError {
+    #[inline]
+    fn to_i64(&self) -> Option<i64> {
+        Some(match *self {
+            PrecompileError::InvalidPublicKey => PrecompileError::InvalidPublicKey as i64,
+            PrecompileError::InvalidRecoveryId => PrecompileError::InvalidRecoveryId as i64,
+            PrecompileError::InvalidSignature => PrecompileError::InvalidSignature as i64,
+            PrecompileError::InvalidDataOffsets => PrecompileError::InvalidDataOffsets as i64,
+            PrecompileError::InvalidInstructionDataSize => {
+                PrecompileError::InvalidInstructionDataSize as i64
+            }
+        })
+    }
+    #[inline]
+    fn to_u64(&self) -> Option<u64> {
+        self.to_i64().map(|x| x as u64)
+    }
+}
+
+impl std::error::Error for PrecompileError {}
+
+impl fmt::Display for PrecompileError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            PrecompileError::InvalidPublicKey => f.write_str("public key is not valid"),
+            PrecompileError::InvalidRecoveryId => f.write_str("id is not valid"),
+            PrecompileError::InvalidSignature => f.write_str("signature is not valid"),
+            PrecompileError::InvalidDataOffsets => f.write_str("offset not valid"),
+            PrecompileError::InvalidInstructionDataSize => {
+                f.write_str("instruction is incorrect size")
+            }
+        }
+    }
+}
+
+impl<T> DecodeError<T> for PrecompileError {
+    fn type_of() -> &'static str {
+        "PrecompileError"
+    }
+}

sdk/src/ed25519_instruction.rs

@@ -5,11 +5,12 @@
 #![cfg(feature = "full")]
 
 use {
-    crate::{instruction::Instruction, precompiles::PrecompileError},
     bytemuck::bytes_of,
     bytemuck_derive::{Pod, Zeroable},
     ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier},
     solana_feature_set::{ed25519_precompile_verify_strict, FeatureSet},
+    solana_instruction::Instruction,
+    solana_precompile_error::PrecompileError,
 };
 
 pub const PUBKEY_SERIALIZED_SIZE: usize = 32;

sdk/src/precompiles.rs

@@ -2,36 +2,13 @@
 
 #![cfg(feature = "full")]
 
+#[deprecated(since = "2.1.0", note = "Use `solana-precompile-error` crate instead.")]
+pub use solana_precompile_error::PrecompileError;
 use {
-    lazy_static::lazy_static,
-    num_derive::{FromPrimitive, ToPrimitive},
-    solana_decode_error::DecodeError,
-    solana_feature_set::FeatureSet,
-    solana_program::{instruction::CompiledInstruction, pubkey::Pubkey},
-    thiserror::Error,
+    lazy_static::lazy_static, solana_feature_set::FeatureSet,
+    solana_program::instruction::CompiledInstruction, solana_pubkey::Pubkey,
 };
 
-/// Precompile errors
-#[derive(Error, Debug, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
-pub enum PrecompileError {
-    #[error("public key is not valid")]
-    InvalidPublicKey,
-    #[error("id is not valid")]
-    InvalidRecoveryId,
-    #[error("signature is not valid")]
-    InvalidSignature,
-    #[error("offset not valid")]
-    InvalidDataOffsets,
-    #[error("instruction is incorrect size")]
-    InvalidInstructionDataSize,
-}
-
-impl<T> DecodeError<T> for PrecompileError {
-    fn type_of() -> &'static str {
-        "PrecompileError"
-    }
-}
-
 /// All precompiled programs must implement the `Verify` function
 pub type Verify = fn(&[u8], &[&[u8]], &FeatureSet) -> std::result::Result<(), PrecompileError>;
 

sdk/src/secp256k1_instruction.rs

@@ -788,10 +788,11 @@
 #![cfg(feature = "full")]
 
 use {
-    crate::{instruction::Instruction, precompiles::PrecompileError},
     digest::Digest,
     serde_derive::{Deserialize, Serialize},
     solana_feature_set::FeatureSet,
+    solana_instruction::Instruction,
+    solana_precompile_error::PrecompileError,
 };
 
 pub const HASHED_PUBKEY_SERIALIZED_SIZE: usize = 20;