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

RPC instruction parser tests are missing some cases (#25951) 

* Fix num-accounts typo and extend test

* Add extra test cases to parse_system

* Add extra test cases to parse_vote

* Add extra test cases to parse_stake

* Fixup parse_bpf_loader

* Add extra test cases to parse_bpf_upgradeable_loader

* Add extra test cases to parse_associated_token
This commit is contained in:
Tyera Eulberg 2022-06-13 18:32:40 -06:00 committed by GitHub
parent fc166daa17
commit 7b786ff331
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 284 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -125,7 +125,7 @@ mod test {
&convert_pubkey(mint),
);
let message = Message::new(&[create_ix], None);
let compiled_instruction = convert_compiled_instruction(&message.instructions[0]);
let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]);
assert_eq!(
parse_associated_token(
&compiled_instruction,
@ -145,6 +145,12 @@ mod test {
})
}
);
compiled_instruction.accounts.pop();
assert!(parse_associated_token(
&compiled_instruction,
&AccountKeys::new(&convert_account_keys(&message), None)
)
.is_err());
}
#[test]
@ -160,7 +166,7 @@ mod test {
&convert_pubkey(mint),
);
let message = Message::new(&[create_ix], None);
let compiled_instruction = convert_compiled_instruction(&message.instructions[0]);
let mut compiled_instruction = convert_compiled_instruction(&message.instructions[0]);
assert_eq!(
parse_associated_token(
&compiled_instruction,
@ -179,5 +185,11 @@ mod test {
})
}
);
compiled_instruction.accounts.pop();
assert!(parse_associated_token(
&compiled_instruction,
&AccountKeys::new(&convert_account_keys(&message), None)
)
.is_err());
}
}

129
transaction-status/src/parse_bpf_loader.rs
View File

@ -22,20 +22,26 @@ pub fn parse_bpf_loader(
));
}
match bpf_loader_instruction {
LoaderInstruction::Write { offset, bytes } => Ok(ParsedInstructionEnum {
instruction_type: "write".to_string(),
info: json!({
"offset": offset,
"bytes": base64::encode(bytes),
"account": account_keys[instruction.accounts[0] as usize].to_string(),
}),
}),
LoaderInstruction::Finalize => Ok(ParsedInstructionEnum {
instruction_type: "finalize".to_string(),
info: json!({
"account": account_keys[instruction.accounts[0] as usize].to_string(),
}),
}),
LoaderInstruction::Write { offset, bytes } => {
check_num_bpf_loader_accounts(&instruction.accounts, 1)?;
Ok(ParsedInstructionEnum {
instruction_type: "write".to_string(),
info: json!({
"offset": offset,
"bytes": base64::encode(bytes),
"account": account_keys[instruction.accounts[0] as usize].to_string(),
}),
})
}
LoaderInstruction::Finalize => {
check_num_bpf_loader_accounts(&instruction.accounts, 2)?;
Ok(ParsedInstructionEnum {
instruction_type: "finalize".to_string(),
info: json!({
"account": account_keys[instruction.accounts[0] as usize].to_string(),
}),
})
}
}
}
@ -147,6 +153,10 @@ pub fn parse_bpf_upgradeable_loader(
}
}
fn check_num_bpf_loader_accounts(accounts: &[u8], num: usize) -> Result<(), ParseInstructionError> {
check_num_accounts(accounts, num, ParsableProgram::BpfLoader)
}
fn check_num_bpf_upgradeable_loader_accounts(
accounts: &[u8],
num: usize,
@ -183,7 +193,7 @@ mod test {
offset,
bytes.clone(),
);
let message = Message::new(&[instruction], Some(&fee_payer));
let mut message = Message::new(&[instruction], Some(&fee_payer));
assert_eq!(
parse_bpf_loader(
&message.instructions[0],
@ -204,9 +214,15 @@ mod test {
&AccountKeys::new(&missing_account_keys, None)
)
.is_err());
message.instructions[0].accounts.pop();
assert!(parse_bpf_loader(
&message.instructions[0],
&AccountKeys::new(&account_keys, None)
)
.is_err());
let instruction = solana_sdk::loader_instruction::finalize(&account_pubkey, &program_id);
let message = Message::new(&[instruction], Some(&fee_payer));
let mut message = Message::new(&[instruction], Some(&fee_payer));
assert_eq!(
parse_bpf_loader(
&message.instructions[0],
@ -225,6 +241,12 @@ mod test {
&AccountKeys::new(&missing_account_keys, None)
)
.is_err());
message.instructions[0].accounts.pop();
assert!(parse_bpf_loader(
&message.instructions[0],
&AccountKeys::new(&account_keys, None)
)
.is_err());
let bad_compiled_instruction = CompiledInstruction {
program_id_index: 3,
@ -264,7 +286,7 @@ mod test {
max_data_len,
)
.unwrap();
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[1],
@ -284,6 +306,14 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[1].accounts.pop();
message.instructions[1].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[1],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -299,7 +329,7 @@ mod test {
offset,
bytes.clone(),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -321,6 +351,13 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -345,7 +382,7 @@ mod test {
max_data_len,
)
.unwrap();
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[1],
@ -372,6 +409,13 @@ mod test {
&AccountKeys::new(&message.account_keys[0..7], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[1].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[1],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -391,7 +435,7 @@ mod test {
&authority_address,
&spill_address,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -416,6 +460,13 @@ mod test {
&AccountKeys::new(&message.account_keys[0..6], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -428,7 +479,7 @@ mod test {
&current_authority_address,
&new_authority_address,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -449,6 +500,14 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -465,7 +524,7 @@ mod test {
&current_authority_address,
Some(&new_authority_address),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -486,13 +545,21 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
let instruction = bpf_loader_upgradeable::set_upgrade_authority(
&program_address,
&current_authority_address,
None,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -513,6 +580,13 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
}
#[test]
@ -522,7 +596,7 @@ mod test {
let authority_address = Pubkey::new_unique();
let instruction =
bpf_loader_upgradeable::close(&close_address, &recipient_address, &authority_address);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_bpf_upgradeable_loader(
&message.instructions[0],
@ -543,5 +617,12 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_bpf_upgradeable_loader(
&message.instructions[0],
&AccountKeys::new(&keys, None)
)
.is_err());
}
}

101
transaction-status/src/parse_stake.rs
View File

@ -329,7 +329,7 @@ mod test {
&lockup,
lamports,
);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_stake(
&message.instructions[1],
@ -358,6 +358,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -373,7 +376,7 @@ mod test {
StakeAuthorize::Staker,
None,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -396,6 +399,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let instruction = instruction::authorize(
&stake_pubkey,
@ -404,7 +411,7 @@ mod test {
StakeAuthorize::Withdrawer,
Some(&custodian_pubkey),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -428,6 +435,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -437,7 +448,7 @@ mod test {
let vote_pubkey = Pubkey::new_unique();
let instruction =
instruction::delegate_stake(&stake_pubkey, &authorized_pubkey, &vote_pubkey);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -461,6 +472,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..5], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -475,7 +489,7 @@ mod test {
lamports,
&split_stake_pubkey,
);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_stake(
&message.instructions[2],
@ -497,6 +511,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -539,7 +556,7 @@ mod test {
lamports,
Some(&custodian_pubkey),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -564,6 +581,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..4], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -571,7 +592,7 @@ mod test {
let stake_pubkey = Pubkey::new_unique();
let authorized_pubkey = Pubkey::new_unique();
let instruction = instruction::deactivate_stake(&stake_pubkey, &authorized_pubkey);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -592,6 +613,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -604,7 +628,7 @@ mod test {
&source_stake_pubkey,
&authorized_pubkey,
);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -627,6 +651,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..4], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -647,7 +674,7 @@ mod test {
StakeAuthorize::Staker,
None,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -672,6 +699,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let instruction = instruction::authorize_with_seed(
&stake_pubkey,
@ -682,7 +713,7 @@ mod test {
StakeAuthorize::Withdrawer,
Some(&custodian_pubkey),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -708,6 +739,11 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -778,7 +814,7 @@ mod test {
custodian: Some(custodian),
};
let instruction = instruction::set_lockup(&keys[1], &lockup, &keys[0]);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -804,6 +840,9 @@ mod test {
&AccountKeys::new(&keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let lockup = LockupArgs {
unix_timestamp: Some(unix_timestamp),
@ -836,7 +875,7 @@ mod test {
custodian: None,
};
let instruction = instruction::set_lockup_checked(&keys[1], &lockup, &keys[0]);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -860,6 +899,9 @@ mod test {
&AccountKeys::new(&keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let lockup = LockupArgs {
unix_timestamp: Some(unix_timestamp),
@ -867,7 +909,7 @@ mod test {
custodian: Some(keys[1]),
};
let instruction = instruction::set_lockup_checked(&keys[2], &lockup, &keys[0]);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -892,6 +934,10 @@ mod test {
&AccountKeys::new(&keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -907,7 +953,7 @@ mod test {
let instructions =
instruction::create_account_checked(&from_pubkey, &stake_pubkey, &authorized, lamports);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_stake(
&message.instructions[1],
@ -929,6 +975,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -945,7 +994,7 @@ mod test {
StakeAuthorize::Staker,
None,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -968,6 +1017,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let instruction = instruction::authorize_checked(
&stake_pubkey,
@ -976,7 +1029,7 @@ mod test {
StakeAuthorize::Withdrawer,
Some(&custodian_pubkey),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -1000,6 +1053,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..4], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -1020,7 +1077,7 @@ mod test {
StakeAuthorize::Staker,
None,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -1045,6 +1102,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
let instruction = instruction::authorize_checked_with_seed(
&stake_pubkey,
@ -1055,7 +1116,7 @@ mod test {
StakeAuthorize::Withdrawer,
Some(&custodian_pubkey),
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_stake(
&message.instructions[0],
@ -1081,5 +1142,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..4], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_stake(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
}

63
transaction-status/src/parse_system.rs
View File

@ -123,7 +123,7 @@ pub fn parse_system(
})
}
SystemInstruction::AuthorizeNonceAccount(authority) => {
check_num_system_accounts(&instruction.accounts, 1)?;
check_num_system_accounts(&instruction.accounts, 2)?;
Ok(ParsedInstructionEnum {
instruction_type: "authorizeNonce".to_string(),
info: json!({
@ -229,7 +229,7 @@ mod test {
space,
&owner_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -252,6 +252,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -259,7 +262,7 @@ mod test {
let account_pubkey = Pubkey::new_unique();
let owner_pubkey = Pubkey::new_unique();
let instruction = system_instruction::assign(&account_pubkey, &owner_pubkey);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -275,6 +278,9 @@ mod test {
}
);
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&[], None)).is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -283,7 +289,7 @@ mod test {
let from_pubkey = Pubkey::new_unique();
let to_pubkey = Pubkey::new_unique();
let instruction = system_instruction::transfer(&from_pubkey, &to_pubkey, lamports);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -304,6 +310,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -324,7 +333,7 @@ mod test {
space,
&owner_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -350,6 +359,10 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -357,7 +370,7 @@ mod test {
let space = 128;
let account_pubkey = Pubkey::new_unique();
let instruction = system_instruction::allocate(&account_pubkey, space);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -373,6 +386,9 @@ mod test {
}
);
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&[], None)).is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -389,7 +405,7 @@ mod test {
space,
&owner_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -412,6 +428,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -426,7 +445,7 @@ mod test {
seed,
&owner_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -448,6 +467,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -466,7 +488,7 @@ mod test {
&to_pubkey,
lamports,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -490,6 +512,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -499,7 +524,7 @@ mod test {
let instruction =
system_instruction::advance_nonce_account(&nonce_pubkey, &authorized_pubkey);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -520,6 +545,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -535,7 +563,7 @@ mod test {
&to_pubkey,
lamports,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -559,6 +587,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..4], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -574,7 +605,7 @@ mod test {
&authorized_pubkey,
lamports,
);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_system(
&message.instructions[1],
@ -596,6 +627,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -609,7 +643,7 @@ mod test {
&authorized_pubkey,
&new_authority_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_system(
&message.instructions[0],
@ -630,5 +664,8 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_system(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
}

40
transaction-status/src/parse_vote.rs
View File

@ -215,7 +215,7 @@ mod test {
&vote_init,
lamports,
);
let message = Message::new(&instructions, None);
let mut message = Message::new(&instructions, None);
assert_eq!(
parse_vote(
&message.instructions[1],
@ -240,6 +240,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -254,7 +257,7 @@ mod test {
&new_authorized_pubkey,
authority_type,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -277,6 +280,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -291,7 +297,7 @@ mod test {
let vote_pubkey = Pubkey::new_unique();
let authorized_voter_pubkey = Pubkey::new_unique();
let instruction = vote_instruction::vote(&vote_pubkey, &authorized_voter_pubkey, vote);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -318,6 +324,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -332,7 +341,7 @@ mod test {
lamports,
&to_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -354,6 +363,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -366,7 +378,7 @@ mod test {
&authorized_withdrawer_pubkey,
&node_pubkey,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -387,6 +399,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..2], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -399,7 +414,7 @@ mod test {
&authorized_withdrawer_pubkey,
commission,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -420,6 +435,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..1], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -436,7 +454,7 @@ mod test {
let proof_hash = Hash::new_from_array([2; 32]);
let instruction =
vote_instruction::vote_switch(&vote_pubkey, &authorized_voter_pubkey, vote, proof_hash);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -464,6 +482,9 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
#[test]
@ -478,7 +499,7 @@ mod test {
&new_authorized_pubkey,
authority_type,
);
let message = Message::new(&[instruction], None);
let mut message = Message::new(&[instruction], None);
assert_eq!(
parse_vote(
&message.instructions[0],
@ -501,5 +522,8 @@ mod test {
&AccountKeys::new(&message.account_keys[0..3], None)
)
.is_err());
let keys = message.account_keys.clone();
message.instructions[0].accounts.pop();
assert!(parse_vote(&message.instructions[0], &AccountKeys::new(&keys, None)).is_err());
}
}