SPL: Use token interface crate

Cargo.toml

@@ -566,10 +566,10 @@ spl-associated-token-account-interface = "1.0.0"
 spl-generic-token = "1.0.1"
 spl-memo-interface = "1.0.0"
 spl-pod = "0.5.1"
-spl-token = "8.0.0"
 spl-token-2022-interface = "1.0.0"
 spl-token-confidential-transfer-proof-extraction = "0.4.0"
 spl-token-group-interface = "0.6.0"
+spl-token-interface = "1.0.0"
 spl-token-metadata-interface = "0.7.0"
 static_assertions = "1.1.0"
 stream-cancel = "0.8.2"

account-decoder/Cargo.toml

@@ -45,9 +45,9 @@ solana-stake-interface = { workspace = true }
 solana-sysvar = { workspace = true }
 solana-vote-interface = { workspace = true, features = ["bincode"] }
 spl-generic-token = { workspace = true }
-spl-token = { workspace = true, features = ["no-entrypoint"] }
 spl-token-2022-interface = { workspace = true }
 spl-token-group-interface = { workspace = true }
+spl-token-interface = { workspace = true }
 spl-token-metadata-interface = { workspace = true }
 thiserror = { workspace = true }
 zstd = { workspace = true }

account-decoder/src/parse_account_data.rs

@@ -33,11 +33,11 @@ pub static PARSABLE_PROGRAM_IDS: std::sync::LazyLock<HashMap<Pubkey, ParsableAcc
         );
         m.insert(config::id(), ParsableAccount::Config);
         m.insert(system_program::id(), ParsableAccount::Nonce);
-        m.insert(spl_token::id(), ParsableAccount::SplToken);
         m.insert(
             spl_token_2022_interface::id(),
             ParsableAccount::SplToken2022,
         );
+        m.insert(spl_token_interface::id(), ParsableAccount::SplToken);
         m.insert(stake::id(), ParsableAccount::Stake);
         m.insert(sysvar::id(), ParsableAccount::Sysvar);
         m.insert(vote::id(), ParsableAccount::Vote);

accounts-cluster-bench/Cargo.toml

@@ -42,7 +42,7 @@ solana-transaction = { workspace = true }
 solana-transaction-status = { workspace = true }
 solana-version = { workspace = true }
 spl-generic-token = { workspace = true }
-spl-token = { workspace = true, features = ["no-entrypoint"] }
+spl-token-interface = { workspace = true }
 
 [target.'cfg(not(any(target_env = "msvc", target_os = "freebsd")))'.dependencies]
 jemallocator = { workspace = true }

accounts-cluster-bench/src/main.rs

@@ -31,7 +31,7 @@ use {
     solana_transaction::Transaction,
     solana_transaction_status::UiTransactionEncoding,
     spl_generic_token::token,
-    spl_token::state::Account,
+    spl_token_interface::state::Account,
     std::{
         cmp::min,
         collections::VecDeque,
@@ -228,17 +228,17 @@ fn make_create_message(
             )];
             if let Some(mint_address) = mint {
                 instructions.push(
-                    spl_token::instruction::initialize_account(
-                        &spl_token::id(),
+                    spl_token_interface::instruction::initialize_account(
+                        &spl_token_interface::id(),
                         &to_pubkey,
                         &mint_address,
                         &base_keypair.pubkey(),
                     )
                     .unwrap(),
                 );
                 instructions.push(
-                    spl_token::instruction::approve(
-                        &spl_token::id(),
+                    spl_token_interface::instruction::approve(
+                        &spl_token_interface::id(),
                         &to_pubkey,
                         &base_keypair.pubkey(),
                         &base_keypair.pubkey(),
@@ -282,8 +282,8 @@ fn make_close_message(
                 Pubkey::create_with_seed(&base_keypair.pubkey(), &seed, &program_id).unwrap();
             if spl_token {
                 Some(
-                    spl_token::instruction::close_account(
-                        &spl_token::id(),
+                    spl_token_interface::instruction::close_account(
+                        &spl_token_interface::id(),
                         &address,
                         &keypair.pubkey(),
                         &base_keypair.pubkey(),
@@ -1422,11 +1422,9 @@ pub mod test {
         solana_measure::measure::Measure,
         solana_native_token::sol_to_lamports,
         solana_poh_config::PohConfig,
+        solana_program_pack::Pack,
         solana_test_validator::TestValidator,
-        spl_token::{
-            solana_program::program_pack::Pack,
-            state::{Account, Mint},
-        },
+        spl_token_interface::state::{Account, Mint},
     };
 
     fn initialize_and_add_secondary_indexes(validator_config: &mut ValidatorConfig) {
@@ -1603,8 +1601,8 @@ pub mod test {
                     spl_mint_len as u64,
                     &token::id(),
                 ),
-                spl_token::instruction::initialize_mint(
-                    &spl_token::id(),
+                spl_token_interface::instruction::initialize_mint(
+                    &spl_token_interface::id(),
                     &spl_mint_keypair.pubkey(),
                     &spl_mint_keypair.pubkey(),
                     None,

rpc/Cargo.toml

@@ -95,8 +95,8 @@ solana-version = { workspace = true }
 solana-vote = { workspace = true }
 solana-vote-program = { workspace = true }
 spl-generic-token = { workspace = true }
-spl-token = { workspace = true, features = ["no-entrypoint"] }
 spl-token-2022-interface = { workspace = true }
+spl-token-interface = { workspace = true }
 stream-cancel = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"] }

rpc/src/parsed_token_accounts.rs

@@ -94,10 +94,10 @@ pub(crate) fn get_mint_owner_and_additional_data(
     bank: &Bank,
     mint: &Pubkey,
 ) -> Result<(Pubkey, SplTokenAdditionalDataV2)> {
-    if mint == &spl_token::native_mint::id() {
+    if mint == &spl_token_interface::native_mint::id() {
         Ok((
-            spl_token::id(),
-            SplTokenAdditionalDataV2::with_decimals(spl_token::native_mint::DECIMALS),
+            spl_token_interface::id(),
+            SplTokenAdditionalDataV2::with_decimals(spl_token_interface::native_mint::DECIMALS),
         ))
     } else {
         let mint_account = bank.get_account(mint).ok_or_else(|| {