From d5195921a9916a0917a1407a8e55e9ac3feaeabd Mon Sep 17 00:00:00 2001 From: Jon Cinque Date: Sat, 30 Sep 2023 00:40:48 +0200 Subject: [PATCH] transaction-status: Remove conversions between spl re-exports and local sdk (#33456) * transaction-status: Remove `convert_pubkey` Ran `git g -l convert_pubkey | xargs sed -i'' -re 's/convert_pubkey\(([^)]+)\)/\1/g'` * Remove convert_compiled_instruction Ran `git g -l convert_compiled_instruction | xargs sed -i'' -re 's/convert_compiled_instruction\(([^)]+)\)/\1/g'` * Cleanup + clippy * Remove instruction conversions in new extensions * Run clippy --fix --- .../src/parse_associated_token.rs | 116 +-- transaction-status/src/parse_token.rs | 890 +++++++----------- .../src/parse_token/extension/cpi_guard.rs | 53 +- .../extension/default_account_state.rs | 28 +- .../parse_token/extension/memo_transfer.rs | 43 +- .../parse_token/extension/metadata_pointer.rs | 29 +- .../extension/mint_close_authority.rs | 21 +- .../extension/permanent_delegate.rs | 13 +- .../src/parse_token/extension/reallocate.rs | 26 +- .../src/parse_token/extension/transfer_fee.rs | 129 ++- .../parse_token/extension/transfer_hook.rs | 29 +- 11 files changed, 528 insertions(+), 849 deletions(-) diff --git a/transaction-status/src/parse_associated_token.rs b/transaction-status/src/parse_associated_token.rs index e03fd185a..868f453f1 100644 --- a/transaction-status/src/parse_associated_token.rs +++ b/transaction-status/src/parse_associated_token.rs @@ -94,48 +94,26 @@ mod test { use spl_associated_token_account::create_associated_token_account as create_associated_token_account_deprecated; use { super::*, + solana_sdk::{message::Message, sysvar}, spl_associated_token_account::{ get_associated_token_address, get_associated_token_address_with_program_id, instruction::{ create_associated_token_account, create_associated_token_account_idempotent, recover_nested, }, - solana_program::{ - instruction::CompiledInstruction as SplAssociatedTokenCompiledInstruction, - message::Message, pubkey::Pubkey as SplAssociatedTokenPubkey, sysvar, - }, }, }; - fn convert_pubkey(pubkey: Pubkey) -> SplAssociatedTokenPubkey { - SplAssociatedTokenPubkey::new_from_array(pubkey.to_bytes()) - } - - fn convert_compiled_instruction( - instruction: &SplAssociatedTokenCompiledInstruction, - ) -> CompiledInstruction { - CompiledInstruction { - program_id_index: instruction.program_id_index, - accounts: instruction.accounts.clone(), - data: instruction.data.clone(), - } - } - #[test] fn test_parse_create_deprecated() { let funder = Pubkey::new_unique(); let wallet_address = Pubkey::new_unique(); let mint = Pubkey::new_unique(); - let associated_account_address = - get_associated_token_address(&convert_pubkey(wallet_address), &convert_pubkey(mint)); + let associated_account_address = get_associated_token_address(&wallet_address, &mint); #[allow(deprecated)] - let create_ix = create_associated_token_account_deprecated( - &convert_pubkey(funder), - &convert_pubkey(wallet_address), - &convert_pubkey(mint), - ); - let message = Message::new(&[create_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let create_ix = create_associated_token_account_deprecated(&funder, &wallet_address, &mint); + let mut message = Message::new(&[create_ix], None); + let compiled_instruction = &mut message.instructions[0]; let expected_parsed_ix = ParsedInstructionEnum { instruction_type: "create".to_string(), info: json!({ @@ -149,7 +127,7 @@ mod test { }; assert_eq!( parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -165,7 +143,7 @@ mod test { compiled_instruction.accounts.remove(rent_account_index); assert_eq!( parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -175,7 +153,7 @@ mod test { // after popping another account, parsing should fail compiled_instruction.accounts.pop(); assert!(parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .is_err()); @@ -187,22 +165,15 @@ mod test { let wallet_address = Pubkey::new_unique(); let mint = Pubkey::new_unique(); let token_program_id = Pubkey::new_unique(); - let associated_account_address = get_associated_token_address_with_program_id( - &convert_pubkey(wallet_address), - &convert_pubkey(mint), - &convert_pubkey(token_program_id), - ); - let create_ix = create_associated_token_account( - &convert_pubkey(funder), - &convert_pubkey(wallet_address), - &convert_pubkey(mint), - &convert_pubkey(token_program_id), - ); - let message = Message::new(&[create_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let associated_account_address = + get_associated_token_address_with_program_id(&wallet_address, &mint, &token_program_id); + let create_ix = + create_associated_token_account(&funder, &wallet_address, &mint, &token_program_id); + let mut message = Message::new(&[create_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -220,7 +191,7 @@ mod test { ); compiled_instruction.accounts.pop(); assert!(parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .is_err()); @@ -232,22 +203,19 @@ mod test { let wallet_address = Pubkey::new_unique(); let mint = Pubkey::new_unique(); let token_program_id = Pubkey::new_unique(); - let associated_account_address = get_associated_token_address_with_program_id( - &convert_pubkey(wallet_address), - &convert_pubkey(mint), - &convert_pubkey(token_program_id), - ); + let associated_account_address = + get_associated_token_address_with_program_id(&wallet_address, &mint, &token_program_id); let create_ix = create_associated_token_account_idempotent( - &convert_pubkey(funder), - &convert_pubkey(wallet_address), - &convert_pubkey(mint), - &convert_pubkey(token_program_id), + &funder, + &wallet_address, + &mint, + &token_program_id, ); - let message = Message::new(&[create_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[create_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -265,7 +233,7 @@ mod test { ); compiled_instruction.accounts.pop(); assert!(parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .is_err()); @@ -278,31 +246,31 @@ mod test { let nested_mint = Pubkey::new_unique(); let token_program_id = Pubkey::new_unique(); let owner_associated_account_address = get_associated_token_address_with_program_id( - &convert_pubkey(wallet_address), - &convert_pubkey(owner_mint), - &convert_pubkey(token_program_id), + &wallet_address, + &owner_mint, + &token_program_id, ); let nested_associated_account_address = get_associated_token_address_with_program_id( &owner_associated_account_address, - &convert_pubkey(nested_mint), - &convert_pubkey(token_program_id), + &nested_mint, + &token_program_id, ); let destination_associated_account_address = get_associated_token_address_with_program_id( - &convert_pubkey(wallet_address), - &convert_pubkey(nested_mint), - &convert_pubkey(token_program_id), + &wallet_address, + &nested_mint, + &token_program_id, ); let recover_ix = recover_nested( - &convert_pubkey(wallet_address), - &convert_pubkey(owner_mint), - &convert_pubkey(nested_mint), - &convert_pubkey(token_program_id), + &wallet_address, + &owner_mint, + &nested_mint, + &token_program_id, ); - let message = Message::new(&[recover_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[recover_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -321,7 +289,7 @@ mod test { ); compiled_instruction.accounts.pop(); assert!(parse_associated_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .is_err()); diff --git a/transaction-status/src/parse_token.rs b/transaction-status/src/parse_token.rs index ce57111c9..ee9a04db3 100644 --- a/transaction-status/src/parse_token.rs +++ b/transaction-status/src/parse_token.rs @@ -809,32 +809,12 @@ fn map_coption_pubkey(pubkey: COption) -> Option { mod test { use { super::*, - solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey}, - spl_token_2022::{ - instruction::*, - solana_program::{ - instruction::CompiledInstruction as SplTokenCompiledInstruction, message::Message, - pubkey::Pubkey as SplTokenPubkey, - }, - }, - std::{iter::repeat_with, str::FromStr}, + solana_sdk::{message::Message, pubkey::Pubkey}, + spl_token_2022::instruction::*, + std::iter::repeat_with, }; - pub(super) fn convert_pubkey(pubkey: Pubkey) -> SplTokenPubkey { - SplTokenPubkey::from_str(&pubkey.to_string()).unwrap() - } - - pub(super) fn convert_compiled_instruction( - instruction: &SplTokenCompiledInstruction, - ) -> CompiledInstruction { - CompiledInstruction { - program_id_index: instruction.program_id_index, - accounts: instruction.accounts.clone(), - data: instruction.data.clone(), - } - } - - fn test_parse_token(program_id: &SplTokenPubkey) { + fn test_parse_token(program_id: &Pubkey) { let mint_pubkey = Pubkey::new_unique(); let mint_authority = Pubkey::new_unique(); let freeze_authority = Pubkey::new_unique(); @@ -843,17 +823,17 @@ mod test { // Test InitializeMint variations let initialize_mint_ix = initialize_mint( program_id, - &convert_pubkey(mint_pubkey), - &convert_pubkey(mint_authority), - Some(&convert_pubkey(freeze_authority)), + &mint_pubkey, + &mint_authority, + Some(&freeze_authority), 2, ) .unwrap(); let message = Message::new(&[initialize_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -869,19 +849,13 @@ mod test { } ); - let initialize_mint_ix = initialize_mint( - program_id, - &convert_pubkey(mint_pubkey), - &convert_pubkey(mint_authority), - None, - 2, - ) - .unwrap(); + let initialize_mint_ix = + initialize_mint(program_id, &mint_pubkey, &mint_authority, None, 2).unwrap(); let message = Message::new(&[initialize_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -899,17 +873,17 @@ mod test { // Test InitializeMint2 let initialize_mint_ix = initialize_mint2( program_id, - &convert_pubkey(mint_pubkey), - &convert_pubkey(mint_authority), - Some(&convert_pubkey(freeze_authority)), + &mint_pubkey, + &mint_authority, + Some(&freeze_authority), 2, ) .unwrap(); let message = Message::new(&[initialize_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -927,18 +901,13 @@ mod test { // Test InitializeAccount let account_pubkey = Pubkey::new_unique(); let owner = Pubkey::new_unique(); - let initialize_account_ix = initialize_account( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(owner), - ) - .unwrap(); + let initialize_account_ix = + initialize_account(program_id, &account_pubkey, &mint_pubkey, &owner).unwrap(); let message = Message::new(&[initialize_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -954,18 +923,13 @@ mod test { ); // Test InitializeAccount2 - let initialize_account_ix = initialize_account2( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(owner), - ) - .unwrap(); + let initialize_account_ix = + initialize_account2(program_id, &account_pubkey, &mint_pubkey, &owner).unwrap(); let message = Message::new(&[initialize_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -981,18 +945,13 @@ mod test { ); // Test InitializeAccount3 - let initialize_account_ix = initialize_account3( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(owner), - ) - .unwrap(); + let initialize_account_ix = + initialize_account3(program_id, &account_pubkey, &mint_pubkey, &owner).unwrap(); let message = Message::new(&[initialize_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1013,20 +972,16 @@ mod test { let multisig_signer2 = Pubkey::new_unique(); let initialize_multisig_ix = initialize_multisig( program_id, - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - &convert_pubkey(multisig_signer2), - ], + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1, &multisig_signer2], 2, ) .unwrap(); let message = Message::new(&[initialize_multisig_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1048,20 +1003,16 @@ mod test { // Test InitializeMultisig2 let initialize_multisig_ix = initialize_multisig2( program_id, - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - &convert_pubkey(multisig_signer2), - ], + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1, &multisig_signer2], 2, ) .unwrap(); let message = Message::new(&[initialize_multisig_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1082,20 +1033,13 @@ mod test { // Test Transfer, incl multisig let recipient = Pubkey::new_unique(); #[allow(deprecated)] - let transfer_ix = transfer( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), - &[], - 42, - ) - .unwrap(); + let transfer_ix = + transfer(program_id, &account_pubkey, &recipient, &owner, &[], 42).unwrap(); let message = Message::new(&[transfer_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1113,21 +1057,18 @@ mod test { #[allow(deprecated)] let transfer_ix = transfer( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], 42, ) .unwrap(); let message = Message::new(&[transfer_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1147,20 +1088,12 @@ mod test { ); // Test Approve, incl multisig - let approve_ix = approve( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), - &[], - 42, - ) - .unwrap(); + let approve_ix = approve(program_id, &account_pubkey, &recipient, &owner, &[], 42).unwrap(); let message = Message::new(&[approve_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1177,21 +1110,18 @@ mod test { let approve_ix = approve( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], 42, ) .unwrap(); let message = Message::new(&[approve_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1211,18 +1141,12 @@ mod test { ); // Test Revoke - let revoke_ix = revoke( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(owner), - &[], - ) - .unwrap(); + let revoke_ix = revoke(program_id, &account_pubkey, &owner, &[]).unwrap(); let message = Message::new(&[revoke_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1239,18 +1163,18 @@ mod test { let new_freeze_authority = Pubkey::new_unique(); let set_authority_ix = set_authority( program_id, - &convert_pubkey(mint_pubkey), - Some(&convert_pubkey(new_freeze_authority)), + &mint_pubkey, + Some(&new_freeze_authority), AuthorityType::FreezeAccount, - &convert_pubkey(freeze_authority), + &freeze_authority, &[], ) .unwrap(); let message = Message::new(&[set_authority_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1267,19 +1191,19 @@ mod test { let set_authority_ix = set_authority( program_id, - &convert_pubkey(account_pubkey), + &account_pubkey, None, AuthorityType::CloseAccount, - &convert_pubkey(owner), + &owner, &[], ) .unwrap(); let message = Message::new(&[set_authority_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; let new_authority: Option = None; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1297,18 +1221,18 @@ mod test { // Test MintTo let mint_to_ix = mint_to( program_id, - &convert_pubkey(mint_pubkey), - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_authority), + &mint_pubkey, + &account_pubkey, + &mint_authority, &[], 42, ) .unwrap(); let message = Message::new(&[mint_to_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1324,20 +1248,12 @@ mod test { ); // Test Burn - let burn_ix = burn( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(owner), - &[], - 42, - ) - .unwrap(); + let burn_ix = burn(program_id, &account_pubkey, &mint_pubkey, &owner, &[], 42).unwrap(); let message = Message::new(&[burn_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1353,19 +1269,13 @@ mod test { ); // Test CloseAccount - let close_account_ix = close_account( - program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), - &[], - ) - .unwrap(); + let close_account_ix = + close_account(program_id, &account_pubkey, &recipient, &owner, &[]).unwrap(); let message = Message::new(&[close_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1382,17 +1292,17 @@ mod test { // Test FreezeAccount let freeze_account_ix = freeze_account( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(freeze_authority), + &account_pubkey, + &mint_pubkey, + &freeze_authority, &[], ) .unwrap(); let message = Message::new(&[freeze_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1409,17 +1319,17 @@ mod test { // Test ThawAccount let thaw_account_ix = thaw_account( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(freeze_authority), + &account_pubkey, + &mint_pubkey, + &freeze_authority, &[], ) .unwrap(); let message = Message::new(&[thaw_account_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1436,20 +1346,20 @@ mod test { // Test TransferChecked, incl multisig let transfer_ix = transfer_checked( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), + &account_pubkey, + &mint_pubkey, + &recipient, + &owner, &[], 42, 2, ) .unwrap(); let message = Message::new(&[transfer_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1472,23 +1382,20 @@ mod test { let transfer_ix = transfer_checked( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &mint_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], 42, 2, ) .unwrap(); let message = Message::new(&[transfer_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1516,20 +1423,20 @@ mod test { // Test ApproveChecked, incl multisig let approve_ix = approve_checked( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), + &account_pubkey, + &mint_pubkey, + &recipient, + &owner, &[], 42, 2, ) .unwrap(); let message = Message::new(&[approve_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1552,23 +1459,20 @@ mod test { let approve_ix = approve_checked( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &mint_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], 42, 2, ) .unwrap(); let message = Message::new(&[approve_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1596,19 +1500,19 @@ mod test { // Test MintToChecked let mint_to_ix = mint_to_checked( program_id, - &convert_pubkey(mint_pubkey), - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_authority), + &mint_pubkey, + &account_pubkey, + &mint_authority, &[], 42, 2, ) .unwrap(); let message = Message::new(&[mint_to_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1631,19 +1535,19 @@ mod test { // Test BurnChecked let burn_ix = burn_checked( program_id, - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(owner), + &account_pubkey, + &mint_pubkey, + &owner, &[], 42, 2, ) .unwrap(); let message = Message::new(&[burn_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1664,12 +1568,12 @@ mod test { ); // Test SyncNative - let sync_native_ix = sync_native(program_id, &convert_pubkey(account_pubkey)).unwrap(); + let sync_native_ix = sync_native(program_id, &account_pubkey).unwrap(); let message = Message::new(&[sync_native_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1683,12 +1587,12 @@ mod test { // Test InitializeImmutableOwner let init_immutable_owner_ix = - initialize_immutable_owner(program_id, &convert_pubkey(account_pubkey)).unwrap(); + initialize_immutable_owner(program_id, &account_pubkey).unwrap(); let message = Message::new(&[init_immutable_owner_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1703,15 +1607,15 @@ mod test { // Test GetAccountDataSize let get_account_data_size_ix = get_account_data_size( program_id, - &convert_pubkey(mint_pubkey), + &mint_pubkey, &[], // This emulates the packed data of spl_token::instruction::get_account_data_size ) .unwrap(); let message = Message::new(&[get_account_data_size_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1725,15 +1629,15 @@ mod test { let get_account_data_size_ix = get_account_data_size( program_id, - &convert_pubkey(mint_pubkey), + &mint_pubkey, &[ExtensionType::ImmutableOwner, ExtensionType::MemoTransfer], ) .unwrap(); let message = Message::new(&[get_account_data_size_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1750,13 +1654,12 @@ mod test { ); // Test AmountToUiAmount - let amount_to_ui_amount_ix = - amount_to_ui_amount(program_id, &convert_pubkey(mint_pubkey), 4242).unwrap(); + let amount_to_ui_amount_ix = amount_to_ui_amount(program_id, &mint_pubkey, 4242).unwrap(); let message = Message::new(&[amount_to_ui_amount_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1771,12 +1674,12 @@ mod test { // Test UiAmountToAmount let ui_amount_to_amount_ix = - ui_amount_to_amount(program_id, &convert_pubkey(mint_pubkey), "42.42").unwrap(); + ui_amount_to_amount(program_id, &mint_pubkey, "42.42").unwrap(); let message = Message::new(&[ui_amount_to_amount_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1803,13 +1706,12 @@ mod test { #[test] fn test_create_native_mint() { let payer = Pubkey::new_unique(); - let create_native_mint_ix = - create_native_mint(&spl_token_2022::id(), &convert_pubkey(payer)).unwrap(); + let create_native_mint_ix = create_native_mint(&spl_token_2022::id(), &payer).unwrap(); let message = Message::new(&[create_native_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -1824,479 +1726,349 @@ mod test { ); } - fn test_token_ix_not_enough_keys(program_id: &SplTokenPubkey) { + fn test_token_ix_not_enough_keys(program_id: &Pubkey) { let keys: Vec = repeat_with(solana_sdk::pubkey::new_rand).take(10).collect(); // Test InitializeMint variations - let initialize_mint_ix = initialize_mint( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - Some(&convert_pubkey(keys[2])), - 2, - ) - .unwrap(); - let message = Message::new(&[initialize_mint_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); + let initialize_mint_ix = + initialize_mint(program_id, &keys[0], &keys[1], Some(&keys[2]), 2).unwrap(); + let mut message = Message::new(&[initialize_mint_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); - let initialize_mint_ix = initialize_mint( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - None, - 2, - ) - .unwrap(); - let message = Message::new(&[initialize_mint_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); + let initialize_mint_ix = initialize_mint(program_id, &keys[0], &keys[1], None, 2).unwrap(); + let mut message = Message::new(&[initialize_mint_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeMint2 - let initialize_mint_ix = initialize_mint2( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - Some(&convert_pubkey(keys[2])), - 2, - ) - .unwrap(); - let message = Message::new(&[initialize_mint_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..0], None)).is_err()); + let initialize_mint_ix = + initialize_mint2(program_id, &keys[0], &keys[1], Some(&keys[2]), 2).unwrap(); + let mut message = Message::new(&[initialize_mint_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..0], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeAccount - let initialize_account_ix = initialize_account( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - ) - .unwrap(); - let message = Message::new(&[initialize_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); + let initialize_account_ix = + initialize_account(program_id, &keys[0], &keys[1], &keys[2]).unwrap(); + let mut message = Message::new(&[initialize_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeAccount2 - let initialize_account_ix = initialize_account2( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - &convert_pubkey(keys[3]), - ) - .unwrap(); - let message = Message::new(&[initialize_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let initialize_account_ix = + initialize_account2(program_id, &keys[0], &keys[1], &keys[3]).unwrap(); + let mut message = Message::new(&[initialize_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeAccount3 - let initialize_account_ix = initialize_account3( - program_id, - &convert_pubkey(keys[0]), - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - ) - .unwrap(); - let message = Message::new(&[initialize_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); + let initialize_account_ix = + initialize_account3(program_id, &keys[0], &keys[1], &keys[2]).unwrap(); + let mut message = Message::new(&[initialize_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeMultisig - let initialize_multisig_ix = initialize_multisig( - program_id, - &convert_pubkey(keys[0]), - &[ - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - ], - 2, - ) - .unwrap(); - let message = Message::new(&[initialize_multisig_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); + let initialize_multisig_ix = + initialize_multisig(program_id, &keys[0], &[&keys[1], &keys[2], &keys[3]], 2).unwrap(); + let mut message = Message::new(&[initialize_multisig_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeMultisig2 - let initialize_multisig_ix = initialize_multisig2( - program_id, - &convert_pubkey(keys[0]), - &[ - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - ], - 2, - ) - .unwrap(); - let message = Message::new(&[initialize_multisig_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); + let initialize_multisig_ix = + initialize_multisig2(program_id, &keys[0], &[&keys[1], &keys[2], &keys[3]], 2).unwrap(); + let mut message = Message::new(&[initialize_multisig_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test Transfer, incl multisig #[allow(deprecated)] - let transfer_ix = transfer( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - ) - .unwrap(); - let message = Message::new(&[transfer_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let transfer_ix = transfer(program_id, &keys[1], &keys[2], &keys[0], &[], 42).unwrap(); + let mut message = Message::new(&[transfer_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); #[allow(deprecated)] let transfer_ix = transfer( program_id, - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[4]), - &[&convert_pubkey(keys[0]), &convert_pubkey(keys[1])], + &keys[2], + &keys[3], + &keys[4], + &[&keys[0], &keys[1]], 42, ) .unwrap(); - let message = Message::new(&[transfer_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); + let mut message = Message::new(&[transfer_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test Approve, incl multisig - let approve_ix = approve( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - ) - .unwrap(); - let message = Message::new(&[approve_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let approve_ix = approve(program_id, &keys[1], &keys[2], &keys[0], &[], 42).unwrap(); + let mut message = Message::new(&[approve_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); let approve_ix = approve( program_id, - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[4]), - &[&convert_pubkey(keys[0]), &convert_pubkey(keys[1])], + &keys[2], + &keys[3], + &keys[4], + &[&keys[0], &keys[1]], 42, ) .unwrap(); - let message = Message::new(&[approve_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); + let mut message = Message::new(&[approve_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..4], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test Revoke - let revoke_ix = revoke( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[0]), - &[], - ) - .unwrap(); - let message = Message::new(&[revoke_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); + let revoke_ix = revoke(program_id, &keys[1], &keys[0], &[]).unwrap(); + let mut message = Message::new(&[revoke_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test SetAuthority let set_authority_ix = set_authority( program_id, - &convert_pubkey(keys[1]), - Some(&convert_pubkey(keys[2])), + &keys[1], + Some(&keys[2]), AuthorityType::FreezeAccount, - &convert_pubkey(keys[0]), + &keys[0], &[], ) .unwrap(); - let message = Message::new(&[set_authority_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); + let mut message = Message::new(&[set_authority_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..1], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test MintTo - let mint_to_ix = mint_to( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - ) - .unwrap(); - let message = Message::new(&[mint_to_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let mint_to_ix = mint_to(program_id, &keys[1], &keys[2], &keys[0], &[], 42).unwrap(); + let mut message = Message::new(&[mint_to_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test Burn - let burn_ix = burn( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - ) - .unwrap(); - let message = Message::new(&[burn_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let burn_ix = burn(program_id, &keys[1], &keys[2], &keys[0], &[], 42).unwrap(); + let mut message = Message::new(&[burn_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test CloseAccount - let close_account_ix = close_account( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - ) - .unwrap(); - let message = Message::new(&[close_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let close_account_ix = + close_account(program_id, &keys[1], &keys[2], &keys[0], &[]).unwrap(); + let mut message = Message::new(&[close_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test FreezeAccount - let freeze_account_ix = freeze_account( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - ) - .unwrap(); - let message = Message::new(&[freeze_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let freeze_account_ix = + freeze_account(program_id, &keys[1], &keys[2], &keys[0], &[]).unwrap(); + let mut message = Message::new(&[freeze_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test ThawAccount - let thaw_account_ix = thaw_account( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - ) - .unwrap(); - let message = Message::new(&[thaw_account_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let thaw_account_ix = thaw_account(program_id, &keys[1], &keys[2], &keys[0], &[]).unwrap(); + let mut message = Message::new(&[thaw_account_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test TransferChecked, incl multisig let transfer_ix = transfer_checked( program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[0]), + &keys[1], + &keys[2], + &keys[3], + &keys[0], &[], 42, 2, ) .unwrap(); - let message = Message::new(&[transfer_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); + let mut message = Message::new(&[transfer_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); let transfer_ix = transfer_checked( program_id, - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[4]), - &convert_pubkey(keys[5]), - &[&convert_pubkey(keys[0]), &convert_pubkey(keys[1])], + &keys[2], + &keys[3], + &keys[4], + &keys[5], + &[&keys[0], &keys[1]], 42, 2, ) .unwrap(); - let message = Message::new(&[transfer_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..5], None)).is_err()); + let mut message = Message::new(&[transfer_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..5], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test ApproveChecked, incl multisig let approve_ix = approve_checked( program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[0]), + &keys[1], + &keys[2], + &keys[3], + &keys[0], &[], 42, 2, ) .unwrap(); - let message = Message::new(&[approve_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); + let mut message = Message::new(&[approve_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..3], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); let approve_ix = approve_checked( program_id, - &convert_pubkey(keys[2]), - &convert_pubkey(keys[3]), - &convert_pubkey(keys[4]), - &convert_pubkey(keys[5]), - &[&convert_pubkey(keys[0]), &convert_pubkey(keys[1])], + &keys[2], + &keys[3], + &keys[4], + &keys[5], + &[&keys[0], &keys[1]], 42, 2, ) .unwrap(); - let message = Message::new(&[approve_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..5], None)).is_err()); + let mut message = Message::new(&[approve_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..5], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 3].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test MintToChecked - let mint_to_ix = mint_to_checked( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - 2, - ) - .unwrap(); - let message = Message::new(&[mint_to_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let mint_to_ix = + mint_to_checked(program_id, &keys[1], &keys[2], &keys[0], &[], 42, 2).unwrap(); + let mut message = Message::new(&[mint_to_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test BurnChecked - let burn_ix = burn_checked( - program_id, - &convert_pubkey(keys[1]), - &convert_pubkey(keys[2]), - &convert_pubkey(keys[0]), - &[], - 42, - 2, - ) - .unwrap(); - let message = Message::new(&[burn_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); + let burn_ix = burn_checked(program_id, &keys[1], &keys[2], &keys[0], &[], 42, 2).unwrap(); + let mut message = Message::new(&[burn_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys[0..2], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test SyncNative - let sync_native_ix = sync_native(program_id, &convert_pubkey(keys[0])).unwrap(); - let message = Message::new(&[sync_native_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&[], None)).is_err()); + let sync_native_ix = sync_native(program_id, &keys[0]).unwrap(); + let mut message = Message::new(&[sync_native_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&[], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test InitializeImmutableOwner - let init_immutable_owner_ix = - initialize_immutable_owner(program_id, &convert_pubkey(keys[0])).unwrap(); - let message = Message::new(&[init_immutable_owner_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&[], None)).is_err()); + let init_immutable_owner_ix = initialize_immutable_owner(program_id, &keys[0]).unwrap(); + let mut message = Message::new(&[init_immutable_owner_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&[], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test GetAccountDataSize - let get_account_data_size_ix = - get_account_data_size(program_id, &convert_pubkey(keys[0]), &[]).unwrap(); - let message = Message::new(&[get_account_data_size_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&[], None)).is_err()); + let get_account_data_size_ix = get_account_data_size(program_id, &keys[0], &[]).unwrap(); + let mut message = Message::new(&[get_account_data_size_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&[], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test AmountToUiAmount - let amount_to_ui_amount_ix = - amount_to_ui_amount(program_id, &convert_pubkey(keys[0]), 4242).unwrap(); - let message = Message::new(&[amount_to_ui_amount_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&[], None)).is_err()); + let amount_to_ui_amount_ix = amount_to_ui_amount(program_id, &keys[0], 4242).unwrap(); + let mut message = Message::new(&[amount_to_ui_amount_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&[], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); // Test UiAmountToAmount - let ui_amount_to_amount_ix = - ui_amount_to_amount(program_id, &convert_pubkey(keys[0]), "42.42").unwrap(); - let message = Message::new(&[ui_amount_to_amount_ix], None); - let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&[], None)).is_err()); + let ui_amount_to_amount_ix = ui_amount_to_amount(program_id, &keys[0], "42.42").unwrap(); + let mut message = Message::new(&[ui_amount_to_amount_ix], None); + let compiled_instruction = &mut message.instructions[0]; + assert!(parse_token(compiled_instruction, &AccountKeys::new(&[], None)).is_err()); compiled_instruction.accounts = compiled_instruction.accounts[0..compiled_instruction.accounts.len() - 1].to_vec(); - assert!(parse_token(&compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); + assert!(parse_token(compiled_instruction, &AccountKeys::new(&keys, None)).is_err()); } #[test] diff --git a/transaction-status/src/parse_token/extension/cpi_guard.rs b/transaction-status/src/parse_token/extension/cpi_guard.rs index 5a7cba0aa..a6a8f26df 100644 --- a/transaction-status/src/parse_token/extension/cpi_guard.rs +++ b/transaction-status/src/parse_token/extension/cpi_guard.rs @@ -40,7 +40,6 @@ pub(in crate::parse_token) fn parse_cpi_guard_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{ extension::cpi_guard::instruction::{disable_cpi_guard, enable_cpi_guard}, @@ -54,18 +53,13 @@ mod test { // Enable, single owner let owner_pubkey = Pubkey::new_unique(); - let enable_cpi_guard_ix = enable_cpi_guard( - &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(owner_pubkey), - &[], - ) - .unwrap(); + let enable_cpi_guard_ix = + enable_cpi_guard(&spl_token_2022::id(), &account_pubkey, &owner_pubkey, &[]).unwrap(); let message = Message::new(&[enable_cpi_guard_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -84,19 +78,16 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let enable_cpi_guard_ix = enable_cpi_guard( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], ) .unwrap(); let message = Message::new(&[enable_cpi_guard_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -114,18 +105,13 @@ mod test { ); // Disable, single owner - let enable_cpi_guard_ix = disable_cpi_guard( - &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(owner_pubkey), - &[], - ) - .unwrap(); + let enable_cpi_guard_ix = + disable_cpi_guard(&spl_token_2022::id(), &account_pubkey, &owner_pubkey, &[]).unwrap(); let message = Message::new(&[enable_cpi_guard_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -144,19 +130,16 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let enable_cpi_guard_ix = disable_cpi_guard( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], ) .unwrap(); let message = Message::new(&[enable_cpi_guard_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/default_account_state.rs b/transaction-status/src/parse_token/extension/default_account_state.rs index d0063e617..aa7a3da01 100644 --- a/transaction-status/src/parse_token/extension/default_account_state.rs +++ b/transaction-status/src/parse_token/extension/default_account_state.rs @@ -53,7 +53,6 @@ pub(in crate::parse_token) fn parse_default_account_state_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{ extension::default_account_state::instruction::{ @@ -69,15 +68,15 @@ mod test { let mint_pubkey = Pubkey::new_unique(); let init_default_account_state_ix = initialize_default_account_state( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), + &mint_pubkey, &AccountState::Frozen, ) .unwrap(); let message = Message::new(&[init_default_account_state_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -94,17 +93,17 @@ mod test { let mint_freeze_authority = Pubkey::new_unique(); let update_default_account_state_ix = update_default_account_state( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(mint_freeze_authority), + &mint_pubkey, + &mint_freeze_authority, &[], &AccountState::Initialized, ) .unwrap(); let message = Message::new(&[update_default_account_state_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -124,20 +123,17 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let update_default_account_state_ix = update_default_account_state( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &mint_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], &AccountState::Initialized, ) .unwrap(); let message = Message::new(&[update_default_account_state_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/memo_transfer.rs b/transaction-status/src/parse_token/extension/memo_transfer.rs index 78fcd5b48..6106e2fab 100644 --- a/transaction-status/src/parse_token/extension/memo_transfer.rs +++ b/transaction-status/src/parse_token/extension/memo_transfer.rs @@ -40,7 +40,6 @@ pub(in crate::parse_token) fn parse_memo_transfer_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{ extension::memo_transfer::instruction::{ @@ -58,16 +57,16 @@ mod test { let owner_pubkey = Pubkey::new_unique(); let enable_memo_transfers_ix = enable_required_transfer_memos( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(owner_pubkey), + &account_pubkey, + &owner_pubkey, &[], ) .unwrap(); let message = Message::new(&[enable_memo_transfers_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -86,19 +85,16 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let enable_memo_transfers_ix = enable_required_transfer_memos( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], ) .unwrap(); let message = Message::new(&[enable_memo_transfers_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -118,16 +114,16 @@ mod test { // Disable, single owner let enable_memo_transfers_ix = disable_required_transfer_memos( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(owner_pubkey), + &account_pubkey, + &owner_pubkey, &[], ) .unwrap(); let message = Message::new(&[enable_memo_transfers_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -146,19 +142,16 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let enable_memo_transfers_ix = disable_required_transfer_memos( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], ) .unwrap(); let message = Message::new(&[enable_memo_transfers_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/metadata_pointer.rs b/transaction-status/src/parse_token/extension/metadata_pointer.rs index e88a14732..657078ca8 100644 --- a/transaction-status/src/parse_token/extension/metadata_pointer.rs +++ b/transaction-status/src/parse_token/extension/metadata_pointer.rs @@ -74,10 +74,7 @@ pub(in crate::parse_token) fn parse_metadata_pointer_instruction( #[cfg(test)] mod test { - use { - super::*, crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, - spl_token_2022::solana_program::message::Message, - }; + use {super::*, solana_sdk::pubkey::Pubkey, spl_token_2022::solana_program::message::Message}; #[test] fn test_parse_metadata_pointer_instruction() { @@ -93,11 +90,11 @@ mod test { Some(metadata_address), ) .unwrap(); - let message = Message::new(&[init_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[init_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -112,11 +109,11 @@ mod test { ); let init_ix = initialize(&spl_token_2022::id(), &mint_pubkey, None, None).unwrap(); - let message = Message::new(&[init_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[init_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -137,11 +134,11 @@ mod test { Some(metadata_address), ) .unwrap(); - let message = Message::new(&[update_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[update_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -167,11 +164,11 @@ mod test { Some(metadata_address), ) .unwrap(); - let message = Message::new(&[update_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[update_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/mint_close_authority.rs b/transaction-status/src/parse_token/extension/mint_close_authority.rs index 71b6f737e..610879612 100644 --- a/transaction-status/src/parse_token/extension/mint_close_authority.rs +++ b/transaction-status/src/parse_token/extension/mint_close_authority.rs @@ -22,7 +22,6 @@ pub(in crate::parse_token) fn parse_initialize_mint_close_authority_instruction( mod test { use { super::*, - crate::parse_token::test::*, serde_json::Value, solana_sdk::pubkey::Pubkey, spl_token_2022::{instruction::*, solana_program::message::Message}, @@ -34,15 +33,15 @@ mod test { let close_authority = Pubkey::new_unique(); let mint_close_authority_ix = initialize_mint_close_authority( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - Some(&convert_pubkey(close_authority)), + &mint_pubkey, + Some(&close_authority), ) .unwrap(); let message = Message::new(&[mint_close_authority_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -55,17 +54,13 @@ mod test { } ); - let mint_close_authority_ix = initialize_mint_close_authority( - &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - None, - ) - .unwrap(); + let mint_close_authority_ix = + initialize_mint_close_authority(&spl_token_2022::id(), &mint_pubkey, None).unwrap(); let message = Message::new(&[mint_close_authority_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/permanent_delegate.rs b/transaction-status/src/parse_token/extension/permanent_delegate.rs index 11af94b1a..262d5ec04 100644 --- a/transaction-status/src/parse_token/extension/permanent_delegate.rs +++ b/transaction-status/src/parse_token/extension/permanent_delegate.rs @@ -19,7 +19,6 @@ pub(in crate::parse_token) fn parse_initialize_permanent_delegate_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{instruction::*, solana_program::message::Message}, }; @@ -28,17 +27,13 @@ mod test { fn test_parse_initialize_permanent_delegate_instruction() { let mint_pubkey = Pubkey::new_unique(); let delegate = Pubkey::new_unique(); - let permanent_delegate_ix = initialize_permanent_delegate( - &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(delegate), - ) - .unwrap(); + let permanent_delegate_ix = + initialize_permanent_delegate(&spl_token_2022::id(), &mint_pubkey, &delegate).unwrap(); let message = Message::new(&[permanent_delegate_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/reallocate.rs b/transaction-status/src/parse_token/extension/reallocate.rs index 2c43f6816..623f8e1b5 100644 --- a/transaction-status/src/parse_token/extension/reallocate.rs +++ b/transaction-status/src/parse_token/extension/reallocate.rs @@ -31,7 +31,6 @@ pub(in crate::parse_token) fn parse_reallocate_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{instruction::reallocate, solana_program::message::Message}, }; @@ -50,18 +49,18 @@ mod test { let owner_pubkey = Pubkey::new_unique(); let reallocate_ix = reallocate( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(payer_pubkey), - &convert_pubkey(owner_pubkey), + &account_pubkey, + &payer_pubkey, + &owner_pubkey, &[], &extension_types, ) .unwrap(); let message = Message::new(&[reallocate_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -83,21 +82,18 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let reallocate_ix = reallocate( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(payer_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &payer_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], &extension_types, ) .unwrap(); let message = Message::new(&[reallocate_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/transfer_fee.rs b/transaction-status/src/parse_token/extension/transfer_fee.rs index 9cdce193c..468e15c54 100644 --- a/transaction-status/src/parse_token/extension/transfer_fee.rs +++ b/transaction-status/src/parse_token/extension/transfer_fee.rs @@ -158,7 +158,6 @@ pub(in crate::parse_token) fn parse_transfer_fee_instruction( mod test { use { super::*, - crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, spl_token_2022::{ extension::transfer_fee::instruction::*, solana_program::message::Message, @@ -176,18 +175,18 @@ mod test { // InitializeTransferFeeConfig variations let init_transfer_fee_config_ix = initialize_transfer_fee_config( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - Some(&convert_pubkey(transfer_fee_config_authority)), - Some(&convert_pubkey(withdraw_withheld_authority)), + &mint_pubkey, + Some(&transfer_fee_config_authority), + Some(&withdraw_withheld_authority), transfer_fee_basis_points, maximum_fee, ) .unwrap(); let message = Message::new(&[init_transfer_fee_config_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -205,7 +204,7 @@ mod test { let init_transfer_fee_config_ix = initialize_transfer_fee_config( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), + &mint_pubkey, None, None, transfer_fee_basis_points, @@ -213,10 +212,10 @@ mod test { ) .unwrap(); let message = Message::new(&[init_transfer_fee_config_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -239,10 +238,10 @@ mod test { let fee = 5; let transfer_checked_with_fee_ix = transfer_checked_with_fee( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(owner), + &account_pubkey, + &mint_pubkey, + &recipient, + &owner, &[], amount, decimals, @@ -250,10 +249,10 @@ mod test { ) .unwrap(); let message = Message::new(&[transfer_checked_with_fee_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -286,24 +285,21 @@ mod test { let multisig_signer1 = Pubkey::new_unique(); let transfer_checked_with_fee_ix = transfer_checked_with_fee( &spl_token_2022::id(), - &convert_pubkey(account_pubkey), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &account_pubkey, + &mint_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], amount, decimals, fee, ) .unwrap(); let message = Message::new(&[transfer_checked_with_fee_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -337,17 +333,17 @@ mod test { // Single authority WithdrawWithheldTokensFromMint let withdraw_withheld_tokens_from_mint_ix = withdraw_withheld_tokens_from_mint( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(withdraw_withheld_authority), + &mint_pubkey, + &recipient, + &withdraw_withheld_authority, &[], ) .unwrap(); let message = Message::new(&[withdraw_withheld_tokens_from_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -364,20 +360,17 @@ mod test { // Multisig WithdrawWithheldTokensFromMint let withdraw_withheld_tokens_from_mint_ix = withdraw_withheld_tokens_from_mint( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &mint_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], ) .unwrap(); let message = Message::new(&[withdraw_withheld_tokens_from_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -400,18 +393,18 @@ mod test { let fee_account1 = Pubkey::new_unique(); let withdraw_withheld_tokens_from_accounts_ix = withdraw_withheld_tokens_from_accounts( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(withdraw_withheld_authority), + &mint_pubkey, + &recipient, + &withdraw_withheld_authority, &[], - &[&convert_pubkey(fee_account0), &convert_pubkey(fee_account1)], + &[&fee_account0, &fee_account1], ) .unwrap(); let message = Message::new(&[withdraw_withheld_tokens_from_accounts_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -432,21 +425,18 @@ mod test { // Multisig WithdrawWithheldTokensFromAccounts let withdraw_withheld_tokens_from_accounts_ix = withdraw_withheld_tokens_from_accounts( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(recipient), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], - &[&convert_pubkey(fee_account0), &convert_pubkey(fee_account1)], + &mint_pubkey, + &recipient, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], + &[&fee_account0, &fee_account1], ) .unwrap(); let message = Message::new(&[withdraw_withheld_tokens_from_accounts_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -471,15 +461,15 @@ mod test { // HarvestWithheldTokensToMint let harvest_withheld_tokens_to_mint_ix = harvest_withheld_tokens_to_mint( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &[&convert_pubkey(fee_account0), &convert_pubkey(fee_account1)], + &mint_pubkey, + &[&fee_account0, &fee_account1], ) .unwrap(); let message = Message::new(&[harvest_withheld_tokens_to_mint_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -498,18 +488,18 @@ mod test { // Single authority SetTransferFee let set_transfer_fee_ix = set_transfer_fee( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(transfer_fee_config_authority), + &mint_pubkey, + &transfer_fee_config_authority, &[], transfer_fee_basis_points, maximum_fee, ) .unwrap(); let message = Message::new(&[set_transfer_fee_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -527,21 +517,18 @@ mod test { // Multisig WithdrawWithheldTokensFromMint let set_transfer_fee_ix = set_transfer_fee( &spl_token_2022::id(), - &convert_pubkey(mint_pubkey), - &convert_pubkey(multisig_pubkey), - &[ - &convert_pubkey(multisig_signer0), - &convert_pubkey(multisig_signer1), - ], + &mint_pubkey, + &multisig_pubkey, + &[&multisig_signer0, &multisig_signer1], transfer_fee_basis_points, maximum_fee, ) .unwrap(); let message = Message::new(&[set_transfer_fee_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let compiled_instruction = &message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), diff --git a/transaction-status/src/parse_token/extension/transfer_hook.rs b/transaction-status/src/parse_token/extension/transfer_hook.rs index e6b33c058..68e3bab2b 100644 --- a/transaction-status/src/parse_token/extension/transfer_hook.rs +++ b/transaction-status/src/parse_token/extension/transfer_hook.rs @@ -68,10 +68,7 @@ pub(in crate::parse_token) fn parse_transfer_hook_instruction( #[cfg(test)] mod test { - use { - super::*, crate::parse_token::test::*, solana_sdk::pubkey::Pubkey, - spl_token_2022::solana_program::message::Message, - }; + use {super::*, solana_sdk::pubkey::Pubkey, spl_token_2022::solana_program::message::Message}; #[test] fn test_parse_transfer_hook_instruction() { @@ -87,11 +84,11 @@ mod test { Some(program_id), ) .unwrap(); - let message = Message::new(&[init_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[init_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -106,11 +103,11 @@ mod test { ); let init_ix = initialize(&spl_token_2022::id(), &mint_pubkey, None, None).unwrap(); - let message = Message::new(&[init_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[init_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -131,11 +128,11 @@ mod test { Some(program_id), ) .unwrap(); - let message = Message::new(&[update_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[update_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(), @@ -161,11 +158,11 @@ mod test { Some(program_id), ) .unwrap(); - let message = Message::new(&[update_ix], None); - let compiled_instruction = convert_compiled_instruction(&message.instructions[0]); + let mut message = Message::new(&[update_ix], None); + let compiled_instruction = &mut message.instructions[0]; assert_eq!( parse_token( - &compiled_instruction, + compiled_instruction, &AccountKeys::new(&message.account_keys, None) ) .unwrap(),