Update workspace dependencies (#67)

* Bump dependencies

* Use individual crates

* Add workspace dependencies

* Fix formatting

* Add allow deprecated

* Remove deprecated function usage

---------

Co-authored-by: Jon C <me@jonc.dev>

Cargo.toml

@@ -31,3 +31,13 @@ config = "scripts/spellcheck.toml"
 pre-release-commit-message = "Publish {{crate_name}} v{{version}}"
 tag-message = "Publish {{crate_name}} v{{version}}"
 consolidate-commits = false
+
+[workspace.dependencies]
+num-traits = "0.2"
+pinocchio = "0.8.4"
+solana-instruction = "2.3.0"
+solana-program-error = "2.2.2"
+solana-program-option = "2.2.1"
+solana-program-pack = "2.2.1"
+solana-pubkey = "2.4.0"
+solana-system-interface = { version="1.0", features=["bincode"] }

interface/Cargo.toml

@@ -12,7 +12,7 @@ readme = "./README.md"
 crate-type = ["rlib"]
 
 [dependencies]
-pinocchio = "0.8.4"
+pinocchio = { workspace = true }
 pinocchio-pubkey = "0.2"
 
 [dev-dependencies]

p-token/Cargo.toml

@@ -15,17 +15,27 @@ crate-type = ["cdylib"]
 logging = []
 
 [dependencies]
-pinocchio = "0.8.4"
+pinocchio = { workspace = true }
 pinocchio-log = { version = "0.4", default-features = false }
 spl-token-interface = { version = "^0", path = "../interface" }
 
 [dev-dependencies]
 assert_matches = "1.5.0"
-num-traits = "0.2"
-solana-program-test = "2.1"
-solana-sdk = "2.1"
-spl-token = { version="^4", features=["no-entrypoint"] }
-spl-token-2022 = { version="^7", features=["no-entrypoint"] }
+num-traits = { workspace = true }
+solana-instruction = { workspace = true }
+solana-keypair = "2.2.3"
+solana-program-error = { workspace = true }
+solana-program-option = { workspace = true }
+solana-program-pack = { workspace = true }
+solana-program-test = "2.3.2"
+solana-pubkey = { workspace = true }
+solana-signature = "2.3.0"
+solana-signer = "2.2.1"
+solana-transaction = "2.2.3"
+solana-transaction-error = "2.2.1"
+solana-system-interface = { workspace = true }
+spl-token = { version="^8", features=["no-entrypoint"] }
+spl-token-2022 = { version="^9", features=["no-entrypoint"] }
 
 [lints]
 workspace = true

p-token/tests/amount_to_ui_amount.rs

@@ -3,7 +3,9 @@ mod setup;
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{pubkey::Pubkey, signature::Signer, transaction::Transaction},
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/approve.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/approve_checked.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/batch.rs

@@ -2,16 +2,15 @@ mod setup;
 
 use {
     crate::setup::TOKEN_PROGRAM_ID,
+    solana_instruction::{AccountMeta, Instruction},
+    solana_keypair::Keypair,
+    solana_program_error::ProgramError,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
 };
 
 fn batch_instruction(instructions: Vec<Instruction>) -> Result<Instruction, ProgramError> {
@@ -57,7 +56,7 @@ async fn batch() {
     // Create a mint
     let mint_a = Keypair::new();
     let mint_authority = Keypair::new();
-    let create_mint_a = system_instruction::create_account(
+    let create_mint_a = create_account(
         &context.payer.pubkey(),
         &mint_a.pubkey(),
         mint_rent,
@@ -76,7 +75,7 @@ async fn batch() {
     // Create a mint 2 with a freeze authority
     let mint_b = Keypair::new();
     let freeze_authority = Pubkey::new_unique();
-    let create_mint_b = system_instruction::create_account(
+    let create_mint_b = create_account(
         &context.payer.pubkey(),
         &mint_b.pubkey(),
         mint_rent,
@@ -98,14 +97,14 @@ async fn batch() {
     let owner_a_ta_a = Keypair::new();
     let owner_b_ta_a = Keypair::new();
 
-    let create_owner_a_ta_a = system_instruction::create_account(
+    let create_owner_a_ta_a = create_account(
         &context.payer.pubkey(),
         &owner_a_ta_a.pubkey(),
         account_rent,
         account_len as u64,
         &TOKEN_PROGRAM_ID,
     );
-    let create_owner_b_ta_a = system_instruction::create_account(
+    let create_owner_b_ta_a = create_account(
         &context.payer.pubkey(),
         &owner_b_ta_a.pubkey(),
         account_rent,

p-token/tests/burn.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/burn_checked.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/close_account.rs

@@ -2,12 +2,11 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/freeze_account.rs

@@ -2,12 +2,11 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_signer::Signer,
+    solana_transaction::Transaction,
     spl_token::state::AccountState,
 };
 

p-token/tests/initialize_account.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]
@@ -51,7 +50,7 @@ async fn initialize_account() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/initialize_account2.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]
@@ -51,7 +50,7 @@ async fn initialize_account2() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/initialize_account3.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]
@@ -51,7 +50,7 @@ async fn initialize_account3() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/initialize_mint.rs

@@ -2,15 +2,14 @@ mod setup;
 
 use {
     setup::TOKEN_PROGRAM_ID,
+    solana_keypair::Keypair,
+    solana_program_option::COption,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
     spl_token_interface::state::mint::Mint,
     std::mem::size_of,
 };
@@ -42,7 +41,7 @@ async fn initialize_mint() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/initialize_mint2.rs

@@ -2,15 +2,14 @@ mod setup;
 
 use {
     setup::TOKEN_PROGRAM_ID,
+    solana_keypair::Keypair,
+    solana_program_option::COption,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
     spl_token_interface::state::mint::Mint,
     std::mem::size_of,
 };
@@ -42,7 +41,7 @@ async fn initialize_mint2() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/initialize_multisig.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::TOKEN_PROGRAM_ID,
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
     spl_token::state::Multisig,
 };
 
@@ -40,7 +39,7 @@ async fn initialize_multisig() {
     // When a new multisig account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &multisig.pubkey(),
             rent.minimum_balance(Multisig::LEN),

p-token/tests/initialize_multisig2.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::TOKEN_PROGRAM_ID,
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
     spl_token::state::Multisig,
 };
 
@@ -40,7 +39,7 @@ async fn initialize_multisig2() {
     // When a new multisig account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &multisig.pubkey(),
             rent.minimum_balance(Multisig::LEN),

p-token/tests/mint_to.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/mint_to_checked.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/revoke.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/set_authority.rs

@@ -2,14 +2,13 @@ mod setup;
 
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_option::COption,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
     spl_token::instruction::AuthorityType,
 };
 

p-token/tests/setup/account.rs

@@ -1,9 +1,7 @@
 use {
-    solana_program_test::ProgramTestContext,
-    solana_sdk::{
-        pubkey::Pubkey, signature::Keypair, signer::Signer, system_instruction,
-        transaction::Transaction,
-    },
+    solana_keypair::Keypair, solana_program_test::ProgramTestContext, solana_pubkey::Pubkey,
+    solana_signer::Signer, solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
 };
 
 pub async fn initialize(
@@ -23,7 +21,7 @@ pub async fn initialize(
     initialize_ix.program_id = *program_id;
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/setup/mint.rs

@@ -1,9 +1,11 @@
 use {
+    solana_keypair::Keypair,
+    solana_program_error::ProgramError,
     solana_program_test::{BanksClientError, ProgramTestContext},
-    solana_sdk::{
-        program_error::ProgramError, pubkey::Pubkey, signature::Keypair, signer::Signer,
-        system_instruction, transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
     spl_token_interface::state::mint::Mint,
     std::mem::size_of,
 };
@@ -34,7 +36,7 @@ pub async fn initialize(
     // Create a new account and initialize as a mint.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size),

p-token/tests/setup/mod.rs

@@ -1,4 +1,4 @@
-use solana_sdk::pubkey::Pubkey;
+use solana_pubkey::Pubkey;
 
 #[allow(dead_code)]
 pub mod account;

p-token/tests/thaw_account.rs

@@ -2,12 +2,11 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_signer::Signer,
+    solana_transaction::Transaction,
     spl_token::state::AccountState,
 };
 

p-token/tests/transfer.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/transfer_checked.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     setup::{account, mint, TOKEN_PROGRAM_ID},
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/ui_amount_to_amount.rs

@@ -3,7 +3,9 @@ mod setup;
 use {
     setup::{mint, TOKEN_PROGRAM_ID},
     solana_program_test::{tokio, ProgramTest},
-    solana_sdk::{pubkey::Pubkey, signature::Signer, transaction::Transaction},
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_transaction::Transaction,
 };
 
 #[tokio::test]

p-token/tests/withdraw_excess_lamports.rs

@@ -5,15 +5,15 @@ mod setup;
 use {
     assert_matches::assert_matches,
     setup::{mint, TOKEN_PROGRAM_ID},
+    solana_instruction::error::InstructionError,
+    solana_keypair::Keypair,
+    solana_program_pack::Pack,
     solana_program_test::{tokio, BanksClientError, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
+    solana_pubkey::Pubkey,
+    solana_signer::Signer,
+    solana_system_interface::instruction::create_account,
+    solana_transaction::Transaction,
+    solana_transaction_error::TransactionError,
     spl_token_interface::state::{account::Account, mint::Mint, multisig::Multisig},
     std::mem::size_of,
 };
@@ -48,7 +48,7 @@ async fn withdraw_excess_lamports_from_mint() {
     // And we initialize a mint account with excess lamports.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -155,7 +155,7 @@ async fn withdraw_excess_lamports_from_account() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -253,7 +253,7 @@ async fn withdraw_excess_lamports_from_multisig() {
     // And we initialize the multisig account.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &multisig.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -348,7 +348,7 @@ async fn fail_withdraw_excess_lamports_from_mint_wrong_authority() {
     // And we initialize a mint account with excess lamports.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -461,7 +461,7 @@ async fn fail_withdraw_excess_lamports_from_account_wrong_authority() {
     // When a new mint account is created and initialized.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -565,7 +565,7 @@ async fn fail_withdraw_excess_lamports_from_multisig_wrong_authority() {
     // And we initialize the multisig account.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &multisig.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -669,7 +669,7 @@ async fn fail_withdraw_excess_lamports_from_multisig_missing_signer() {
     // And we initialize the multisig account.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &multisig.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -769,7 +769,7 @@ async fn withdraw_excess_lamports_from_mint_with_no_authority() {
     // And we initialize a mint account with excess lamports.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &mint_account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -897,7 +897,7 @@ async fn fail_withdraw_excess_lamports_from_mint_with_authority_and_mint_as_sign
     // And we initialize a mint account with excess lamports.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &mint_account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,
@@ -997,7 +997,7 @@ async fn fail_withdraw_excess_lamports_from_mint_with_no_authority_and_authority
     // And we initialize a mint account with excess lamports.
 
     let instructions = vec![
-        system_instruction::create_account(
+        create_account(
             &context.payer.pubkey(),
             &mint_account.pubkey(),
             rent.minimum_balance(account_size) + excess_lamports,

program/Cargo.toml

@@ -15,32 +15,38 @@ test-sbf = []
 arrayref = "0.3.9"
 bytemuck = "1.20.0"
 num-derive = "0.4"
-num-traits = "0.2"
+num-traits = { workspace = true }
 num_enum = "0.7.3"
-solana-account-info = "2.2.0"
-solana-cpi = "2.2.0"
-solana-decode-error = "2.2.0"
-solana-instruction = "2.2.0"
-solana-msg = "2.2.0"
-solana-program-entrypoint = "2.2.0"
-solana-program-error = "2.2.0"
-solana-program-memory = "2.2.0"
-solana-program-option = "2.2.0"
-solana-program-pack = "2.2.0"
-solana-pubkey = { version = "2.2.0", features = ["bytemuck"] }
-solana-rent = "2.2.0"
-solana-sdk-ids = "2.2.0"
-solana-sysvar = { version = "2.2.0", features = ["bincode"] }
+solana-account-info = "2.3.0"
+solana-cpi = "2.2.1"
+solana-instruction = { workspace = true }
+solana-msg = "2.2.1"
+solana-program-entrypoint = "2.3.0"
+solana-program-error = { workspace = true }
+solana-program-memory = "2.3.1"
+solana-program-option = { workspace = true }
+solana-program-pack = { workspace = true }
+solana-pubkey = { workspace = true, features = ["bytemuck"] }
+solana-rent = "2.2.1"
+solana-sdk-ids = "2.2.1"
+solana-sysvar = { version = "2.2.2", features = ["bincode"] }
 thiserror = "2.0"
 
 [dev-dependencies]
 lazy_static = "1.5.0"
-mollusk-svm = "0.1.0"
+mollusk-svm = "0.3.0"
+mollusk-svm-fuzz-fixture = "0.3.0"
 proptest = "1.5"
 serial_test = "3.2.0"
-solana-clock = "2.2.1"
+solana-account = "2.2.1"
+solana-account-info = "2.3.0"
+solana-clock = "2.2.2"
 solana-native-token = "2.2.1"
-solana-sdk = "2.2.1"
+solana-program-entrypoint = "2.3.0"
+solana-rent = { version = "2.2.1", features = ["sysvar"] }
+solana-system-interface = { version="1.0", features=["bincode"] }
+strum = "0.24"
+strum_macros = "0.24"
 
 [lib]
 crate-type = ["cdylib", "lib"]

program/src/entrypoint.rs

@@ -3,7 +3,8 @@
 use {
     crate::{error::TokenError, processor::Processor},
     solana_account_info::AccountInfo,
-    solana_program_error::{PrintProgramError, ProgramResult},
+    solana_msg::msg,
+    solana_program_error::{ProgramResult, ToStr},
     solana_pubkey::Pubkey,
 };
 
@@ -15,7 +16,7 @@ fn process_instruction(
 ) -> ProgramResult {
     if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
         // catch the error so we can print it
-        error.print::<TokenError>();
+        msg!(error.to_str::<TokenError>());
         return Err(error);
     }
     Ok(())

program/src/error.rs

@@ -2,13 +2,12 @@
 
 use {
     num_derive::FromPrimitive,
-    solana_decode_error::DecodeError,
-    solana_msg::msg,
-    solana_program_error::{PrintProgramError, ProgramError},
+    solana_program_error::{ProgramError, ToStr},
     thiserror::Error,
 };
 
 /// Errors that may be returned by the Token program.
+#[cfg_attr(test, derive(strum_macros::FromRepr, strum_macros::EnumIter))]
 #[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
 pub enum TokenError {
     // 0
@@ -84,56 +83,84 @@ impl From<TokenError> for ProgramError {
         ProgramError::Custom(e as u32)
     }
 }
-impl<T> DecodeError<T> for TokenError {
-    fn type_of() -> &'static str {
-        "TokenError"
+
+impl TryFrom<u32> for TokenError {
+    type Error = ProgramError;
+    fn try_from(error: u32) -> Result<Self, Self::Error> {
+        match error {
+            0 => Ok(TokenError::NotRentExempt),
+            1 => Ok(TokenError::InsufficientFunds),
+            2 => Ok(TokenError::InvalidMint),
+            3 => Ok(TokenError::MintMismatch),
+            4 => Ok(TokenError::OwnerMismatch),
+            5 => Ok(TokenError::FixedSupply),
+            6 => Ok(TokenError::AlreadyInUse),
+            7 => Ok(TokenError::InvalidNumberOfProvidedSigners),
+            8 => Ok(TokenError::InvalidNumberOfRequiredSigners),
+            9 => Ok(TokenError::UninitializedState),
+            10 => Ok(TokenError::NativeNotSupported),
+            11 => Ok(TokenError::NonNativeHasBalance),
+            12 => Ok(TokenError::InvalidInstruction),
+            13 => Ok(TokenError::InvalidState),
+            14 => Ok(TokenError::Overflow),
+            15 => Ok(TokenError::AuthorityTypeNotSupported),
+            16 => Ok(TokenError::MintCannotFreeze),
+            17 => Ok(TokenError::AccountFrozen),
+            18 => Ok(TokenError::MintDecimalsMismatch),
+            19 => Ok(TokenError::NonNativeNotSupported),
+            _ => Err(ProgramError::InvalidArgument),
+        }
     }
 }
 
-impl PrintProgramError for TokenError {
-    fn print<E>(&self)
-    where
-        E: 'static
-            + std::error::Error
-            + DecodeError<E>
-            + PrintProgramError
-            + num_traits::FromPrimitive,
-    {
+impl ToStr for TokenError {
+    fn to_str<E>(&self) -> &'static str {
         match self {
-            TokenError::NotRentExempt => msg!("Error: Lamport balance below rent-exempt threshold"),
-            TokenError::InsufficientFunds => msg!("Error: insufficient funds"),
-            TokenError::InvalidMint => msg!("Error: Invalid Mint"),
-            TokenError::MintMismatch => msg!("Error: Account not associated with this Mint"),
-            TokenError::OwnerMismatch => msg!("Error: owner does not match"),
-            TokenError::FixedSupply => msg!("Error: the total supply of this token is fixed"),
-            TokenError::AlreadyInUse => msg!("Error: account or token already in use"),
+            TokenError::NotRentExempt => "Error: Lamport balance below rent-exempt threshold",
+            TokenError::InsufficientFunds => "Error: insufficient funds",
+            TokenError::InvalidMint => "Error: Invalid Mint",
+            TokenError::MintMismatch => "Error: Account not associated with this Mint",
+            TokenError::OwnerMismatch => "Error: owner does not match",
+            TokenError::FixedSupply => "Error: the total supply of this token is fixed",
+            TokenError::AlreadyInUse => "Error: account or token already in use",
             TokenError::InvalidNumberOfProvidedSigners => {
-                msg!("Error: Invalid number of provided signers")
+                "Error: Invalid number of provided signers"
             }
             TokenError::InvalidNumberOfRequiredSigners => {
-                msg!("Error: Invalid number of required signers")
-            }
-            TokenError::UninitializedState => msg!("Error: State is uninitialized"),
-            TokenError::NativeNotSupported => {
-                msg!("Error: Instruction does not support native tokens")
+                "Error: Invalid number of required signers"
             }
+            TokenError::UninitializedState => "Error: State is uninitialized",
+            TokenError::NativeNotSupported => "Error: Instruction does not support native tokens",
             TokenError::NonNativeHasBalance => {
-                msg!("Error: Non-native account can only be closed if its balance is zero")
+                "Error: Non-native account can only be closed if its balance is zero"
             }
-            TokenError::InvalidInstruction => msg!("Error: Invalid instruction"),
-            TokenError::InvalidState => msg!("Error: Invalid account state for operation"),
-            TokenError::Overflow => msg!("Error: Operation overflowed"),
+            TokenError::InvalidInstruction => "Error: Invalid instruction",
+            TokenError::InvalidState => "Error: Invalid account state for operation",
+            TokenError::Overflow => "Error: Operation overflowed",
             TokenError::AuthorityTypeNotSupported => {
-                msg!("Error: Account does not support specified authority type")
-            }
-            TokenError::MintCannotFreeze => msg!("Error: This token mint cannot freeze accounts"),
-            TokenError::AccountFrozen => msg!("Error: Account is frozen"),
-            TokenError::MintDecimalsMismatch => {
-                msg!("Error: decimals different from the Mint decimals")
+                "Error: Account does not support specified authority type"
             }
+            TokenError::MintCannotFreeze => "Error: This token mint cannot freeze accounts",
+            TokenError::AccountFrozen => "Error: Account is frozen",
+            TokenError::MintDecimalsMismatch => "Error: decimals different from the Mint decimals",
             TokenError::NonNativeNotSupported => {
-                msg!("Error: Instruction does not support non-native tokens")
+                "Error: Instruction does not support non-native tokens"
             }
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use {super::*, strum::IntoEnumIterator};
+    #[test]
+    fn test_parse_error_from_primitive_exhaustive() {
+        for variant in TokenError::iter() {
+            let variant_u32 = variant as u32;
+            assert_eq!(
+                TokenError::from_repr(variant_u32 as usize).unwrap(),
+                TokenError::try_from(variant_u32).unwrap()
+            );
+        }
+    }
+}

program/src/lib.rs

@@ -24,7 +24,7 @@ pub mod solana_program {
         pub use solana_instruction::{AccountMeta, Instruction};
     }
     pub mod program_error {
-        pub use solana_program_error::{PrintProgramError, ProgramError};
+        pub use solana_program_error::ProgramError;
     }
     pub mod program_option {
         pub use solana_program_option::COption;

program/src/native_mint.rs

@@ -8,16 +8,13 @@ solana_pubkey::declare_id!("So11111111111111111111111111111111111111112");
 
 #[cfg(test)]
 mod tests {
-    use {super::*, solana_native_token::*};
+    use {super::*, solana_native_token::sol_str_to_lamports};
 
     #[test]
     fn test_decimals() {
-        assert!(
-            (lamports_to_sol(42) - crate::amount_to_ui_amount(42, DECIMALS)).abs() < f64::EPSILON
-        );
         assert_eq!(
-            sol_to_lamports(42.),
-            crate::ui_amount_to_amount(42., DECIMALS)
+            sol_str_to_lamports("42.").unwrap(),
+            crate::try_ui_amount_into_amount("42.".to_string(), DECIMALS).unwrap()
         );
     }
 }

program/src/processor.rs

@@ -1041,7 +1041,7 @@ mod tests {
     use {
         super::*,
         solana_clock::Epoch,
-        solana_program_error::PrintProgramError,
+        solana_program_error::ToStr,
         std::sync::{Arc, RwLock},
     };
 
@@ -1056,7 +1056,7 @@ mod tests {
     #[test]
     fn test_print_error() {
         let error = return_token_error_as_program_error();
-        error.print::<TokenError>();
+        error.to_str::<TokenError>();
     }
 
     #[test]

program/tests/assert_instruction_count.rs

@@ -2,11 +2,9 @@ mod setup;
 
 use {
     mollusk_svm::{result::Check, Mollusk},
-    solana_sdk::{
-        account::{Account as SolanaAccount, ReadableAccount},
-        program_pack::Pack,
-        pubkey::Pubkey,
-    },
+    solana_account::{Account as SolanaAccount, ReadableAccount},
+    solana_program_pack::Pack,
+    solana_pubkey::Pubkey,
     spl_token::{
         id, instruction,
         state::{Account, Mint},

program/tests/close_account.rs

@@ -2,13 +2,12 @@ mod setup;
 
 use {
     mollusk_svm::{result::Check, Mollusk},
-    solana_sdk::{
-        account::{Account as SolanaAccount, ReadableAccount},
-        program_error::ProgramError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        system_instruction, system_program,
-    },
+    solana_account::{Account as SolanaAccount, ReadableAccount},
+    solana_program_error::ProgramError,
+    solana_program_pack::Pack,
+    solana_pubkey::Pubkey,
+    solana_sdk_ids::system_program,
+    solana_system_interface::instruction::{create_account, transfer},
     spl_token::{instruction, state::Account},
 };
 
@@ -36,7 +35,7 @@ fn success_init_after_close_account() {
                 &[Check::success()],
             ),
             (
-                &system_instruction::create_account(
+                &create_account(
                     &owner,
                     &account,
                     1_000_000_000,
@@ -96,7 +95,7 @@ fn fail_init_after_close_account() {
                 &[Check::success()],
             ),
             (
-                &system_instruction::transfer(&owner, &account, 1_000_000_000),
+                &transfer(&owner, &account, 1_000_000_000),
                 &[Check::success()],
             ),
             (

program/tests/processor.rs

@@ -3,18 +3,15 @@
 use {
     mollusk_svm::{result::Check, Mollusk},
     serial_test::serial,
-    solana_sdk::{
-        account::{create_account_for_test, Account as SolanaAccount, ReadableAccount},
-        account_info::{AccountInfo, IntoAccountInfo},
-        entrypoint::ProgramResult,
-        instruction::Instruction,
-        program_error::ProgramError,
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        rent::Rent,
-        sysvar::rent,
-    },
+    solana_account::{create_account_for_test, Account as SolanaAccount, ReadableAccount},
+    solana_account_info::{AccountInfo, IntoAccountInfo},
+    solana_instruction::Instruction,
+    solana_program_error::{ProgramError, ProgramResult},
+    solana_program_option::COption,
+    solana_program_pack::Pack,
+    solana_pubkey::Pubkey,
+    solana_rent::Rent,
+    solana_sdk_ids::sysvar::rent,
     spl_token::{
         error::TokenError,
         instruction::{

program/tests/setup.rs

@@ -1,7 +1,8 @@
 use {
-    solana_sdk::{
-        account::Account as SolanaAccount, program_pack::Pack, pubkey::Pubkey, rent::Rent,
-    },
+    solana_account::Account as SolanaAccount,
+    solana_program_pack::Pack,
+    solana_pubkey::Pubkey,
+    solana_rent::Rent,
     spl_token::state::{Account, AccountState, Mint},
 };