blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Jon Cinque 2023-09-30 00:40:48 +02:00 committed by GitHub
parent 4866789b67
commit d5195921a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 528 additions and 849 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
transaction-status/src/parse_associated_token.rs
View File

@ -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());

890
transaction-status/src/parse_token.rs
View File

File diff suppressed because it is too large Load Diff

53
transaction-status/src/parse_token/extension/cpi_guard.rs
View File

@ -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(),

28
transaction-status/src/parse_token/extension/default_account_state.rs
View File

@ -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(),

43
transaction-status/src/parse_token/extension/memo_transfer.rs
View File

@ -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(),

29
transaction-status/src/parse_token/extension/metadata_pointer.rs
View File

@ -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(),

21
transaction-status/src/parse_token/extension/mint_close_authority.rs
View File

@ -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(),

13
transaction-status/src/parse_token/extension/permanent_delegate.rs
View File

@ -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(),

26
transaction-status/src/parse_token/extension/reallocate.rs
View File

@ -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(),

129
transaction-status/src/parse_token/extension/transfer_fee.rs
View File

@ -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(),

29
transaction-status/src/parse_token/extension/transfer_hook.rs
View File

@ -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(),