remove solana-program from token-metadata-interface (#7431)

* remove solana-program from token-metadata-interface

* finish removing solana-program

Author: kevinheavey

Cargo.lock

@@ -12,17 +12,25 @@ serde-traits = ["dep:serde", "spl-pod/serde-traits"]
 
 [dependencies]
 borsh = "1.5.1"
+num-derive = "0.4"
+num-traits = "0.2"
 serde = { version = "1.0.214", optional = true }
-solana-program = "2.1.0"
+solana-borsh = "2.1.0"
+solana-decode-error = "2.1.0"
+solana-instruction = "2.1.0"
+solana-msg = "2.1.0"
+solana-program-error = "2.1.0"
 spl-discriminator = { version = "0.3.0", path = "../../libraries/discriminator" }
-spl-program-error = { version = "0.5.0", path = "../../libraries/program-error" }
+solana-pubkey = "2.1.0"
 spl-type-length-value = { version = "0.6.0", path = "../../libraries/type-length-value" }
 spl-pod = { version = "0.4.0", path = "../../libraries/pod", features = [
   "borsh",
 ] }
+thiserror = "1.0"
 
 [dev-dependencies]
 serde_json = "1.0.132"
+solana-sha256-hasher = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]

token-metadata/interface/Cargo.toml

@@ -1,13 +1,18 @@
 //! Interface error types
 
-use spl_program_error::*;
+use {
+    solana_decode_error::DecodeError,
+    solana_msg::msg,
+    solana_program_error::{PrintProgramError, ProgramError},
+};
 
 /// Errors that may be returned by the interface.
-#[spl_program_error(hash_error_code_start = 901_952_957)]
+#[repr(u32)]
+#[derive(Clone, Debug, Eq, thiserror::Error, num_derive::FromPrimitive, PartialEq)]
 pub enum TokenMetadataError {
     /// Incorrect account provided
     #[error("Incorrect account provided")]
-    IncorrectAccount,
+    IncorrectAccount = 901_952_957,
     /// Mint has no mint authority
     #[error("Mint has no mint authority")]
     MintHasNoMintAuthority,
@@ -24,3 +29,47 @@ pub enum TokenMetadataError {
     #[error("Key not found in metadata account")]
     KeyNotFound,
 }
+
+impl From<TokenMetadataError> for ProgramError {
+    fn from(e: TokenMetadataError) -> Self {
+        ProgramError::Custom(e as u32)
+    }
+}
+
+impl<T> DecodeError<T> for TokenMetadataError {
+    fn type_of() -> &'static str {
+        "TokenMetadataError"
+    }
+}
+
+impl PrintProgramError for TokenMetadataError {
+    fn print<E>(&self)
+    where
+        E: 'static
+            + std::error::Error
+            + DecodeError<E>
+            + PrintProgramError
+            + num_traits::FromPrimitive,
+    {
+        match self {
+            TokenMetadataError::IncorrectAccount => {
+                msg!("Incorrect account provided")
+            }
+            TokenMetadataError::MintHasNoMintAuthority => {
+                msg!("Mint has no mint authority")
+            }
+            TokenMetadataError::IncorrectMintAuthority => {
+                msg!("Incorrect mint authority has signed the instruction",)
+            }
+            TokenMetadataError::IncorrectUpdateAuthority => {
+                msg!("Incorrect metadata update authority has signed the instruction",)
+            }
+            TokenMetadataError::ImmutableMetadata => {
+                msg!("Token metadata has no update authority")
+            }
+            TokenMetadataError::KeyNotFound => {
+                msg!("Key not found in metadata account")
+            }
+        }
+    }
+}

token-metadata/interface/src/error.rs

@@ -5,11 +5,9 @@ use serde::{Deserialize, Serialize};
 use {
     crate::state::Field,
     borsh::{BorshDeserialize, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
+    solana_instruction::{AccountMeta, Instruction},
+    solana_program_error::ProgramError,
+    solana_pubkey::Pubkey,
     spl_discriminator::{discriminator::ArrayDiscriminator, SplDiscriminate},
     spl_pod::optional_keys::OptionalNonZeroPubkey,
 };
@@ -323,7 +321,7 @@ pub fn emit(
 mod test {
     #[cfg(feature = "serde-traits")]
     use std::str::FromStr;
-    use {super::*, crate::NAMESPACE, solana_program::hash};
+    use {super::*, crate::NAMESPACE, solana_sha256_hasher::hashv};
 
     fn check_pack_unpack<T: BorshSerialize>(
         instruction: TokenMetadataInstruction,
@@ -350,7 +348,7 @@ mod test {
             uri: uri.to_string(),
         };
         let check = TokenMetadataInstruction::Initialize(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:initialize_account").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:initialize_account").as_bytes()]);
         let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
         check_pack_unpack(check, discriminator, data);
     }
@@ -364,7 +362,7 @@ mod test {
             value: value.to_string(),
         };
         let check = TokenMetadataInstruction::UpdateField(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:updating_field").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:updating_field").as_bytes()]);
         let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
         check_pack_unpack(check, discriminator, data);
     }
@@ -376,7 +374,7 @@ mod test {
             idempotent: true,
         };
         let check = TokenMetadataInstruction::RemoveKey(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:remove_key_ix").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:remove_key_ix").as_bytes()]);
         let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
         check_pack_unpack(check, discriminator, data);
     }
@@ -387,7 +385,7 @@ mod test {
             new_authority: OptionalNonZeroPubkey::default(),
         };
         let check = TokenMetadataInstruction::UpdateAuthority(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:update_the_authority").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:update_the_authority").as_bytes()]);
         let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
         check_pack_unpack(check, discriminator, data);
     }
@@ -399,7 +397,7 @@ mod test {
             end: Some(10),
         };
         let check = TokenMetadataInstruction::Emit(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:emitter").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:emitter").as_bytes()]);
         let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
         check_pack_unpack(check, discriminator, data);
     }

token-metadata/interface/src/instruction.rs

@@ -10,7 +10,9 @@ pub mod state;
 
 // Export current sdk types for downstream users building with a different sdk
 // version Export borsh for downstream users
-pub use {borsh, solana_program};
+pub use {
+    borsh, solana_borsh, solana_decode_error, solana_instruction, solana_msg, solana_program_error,
+};
 
 /// Namespace for all programs implementing token-metadata
 pub const NAMESPACE: &str = "spl_token_metadata_interface";

token-metadata/interface/src/lib.rs

@@ -4,11 +4,9 @@
 use serde::{Deserialize, Serialize};
 use {
     borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        borsh1::{get_instance_packed_len, try_from_slice_unchecked},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
+    solana_borsh::v1::{get_instance_packed_len, try_from_slice_unchecked},
+    solana_program_error::ProgramError,
+    solana_pubkey::Pubkey,
     spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
     spl_pod::optional_keys::OptionalNonZeroPubkey,
     spl_type_length_value::{
@@ -125,11 +123,11 @@ pub enum Field {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::NAMESPACE, solana_program::hash};
+    use {super::*, crate::NAMESPACE, solana_sha256_hasher::hashv};
 
     #[test]
     fn discriminator() {
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:token_metadata").as_bytes()]);
+        let preimage = hashv(&[format!("{NAMESPACE}:token_metadata").as_bytes()]);
         let discriminator =
             ArrayDiscriminator::try_from(&preimage.as_ref()[..ArrayDiscriminator::LENGTH]).unwrap();
         assert_eq!(TokenMetadata::SPL_DISCRIMINATOR, discriminator);