certusone
/
metaplex
mirror of https://github.com/certusone/metaplex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Cargo format, update, clippy fix, fix (#228) 

* Cargo fmt

* Cargo update

* cargo +nightly clippy --fix -Z unstable-options

* Cargo fix
This commit is contained in:
sigaloid 2021-08-24 10:23:41 -04:00 committed by GitHub
parent 194a82f35e
commit 61c124acf0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 443 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

699
rust/Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

20
rust/auction/cli/src/main.rs
View File

@ -42,7 +42,7 @@ fn create_auction(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) {
let mint = read_keypair_file(app_matches.value_of("mint").unwrap()).unwrap(); let mint = read_keypair_file(app_matches.value_of("mint").unwrap()).unwrap();
// Auction seeds. // Auction seeds.
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), &resource.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref(), resource.as_ref()];
let (auction_pubkey, _) = Pubkey::find_program_address(seeds, &program_key); let (auction_pubkey, _) = Pubkey::find_program_address(seeds, &program_key);
// Configure a price floor // Configure a price floor
@ -199,7 +199,7 @@ fn place_bid(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) {
let bidder = read_keypair_file(app_matches.value_of("bidder").unwrap()).unwrap(); let bidder = read_keypair_file(app_matches.value_of("bidder").unwrap()).unwrap();
// Auction seeds. // Auction seeds.
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), &resource.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref(), resource.as_ref()];
let (auction_pubkey, _) = Pubkey::find_program_address(seeds, &program_key); let (auction_pubkey, _) = Pubkey::find_program_address(seeds, &program_key);
// Parse CLI amount value, fail if not a number. // Parse CLI amount value, fail if not a number.
@ -342,14 +342,14 @@ fn claim_bid(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) {
let destination = read_keypair_file(app_matches.value_of("destination").unwrap()).unwrap(); let destination = read_keypair_file(app_matches.value_of("destination").unwrap()).unwrap();
// Auction seeds. // Auction seeds.
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), &resource.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref(), resource.as_ref()];
let (auction, _) = Pubkey::find_program_address(seeds, &program_key); let (auction, _) = Pubkey::find_program_address(seeds, &program_key);
let bidder_pubkey = bidder.pubkey(); let bidder_pubkey = bidder.pubkey();
let seeds = &[ let seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
&program_key.as_ref(), program_key.as_ref(),
&auction.as_ref(), auction.as_ref(),
&bidder_pubkey.as_ref(), bidder_pubkey.as_ref(),
]; ];
let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key); let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key);
let bidpot_data = client.get_account(&bidpot).unwrap(); let bidpot_data = client.get_account(&bidpot).unwrap();
@ -435,14 +435,14 @@ fn cancel_bid(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) {
let bidder = read_keypair_file(app_matches.value_of("bidder").unwrap()).unwrap(); let bidder = read_keypair_file(app_matches.value_of("bidder").unwrap()).unwrap();
// Load Bidpot data. // Load Bidpot data.
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), &resource.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref(), resource.as_ref()];
let (auction, _) = Pubkey::find_program_address(seeds, &program_key); let (auction, _) = Pubkey::find_program_address(seeds, &program_key);
let bidder_pubkey = bidder.pubkey(); let bidder_pubkey = bidder.pubkey();
let seeds = &[ let seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
&program_key.as_ref(), program_key.as_ref(),
&auction.as_ref(), auction.as_ref(),
&bidder_pubkey.as_ref(), bidder_pubkey.as_ref(),
]; ];
let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key); let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key);
let bidpot_data = client.get_account(&bidpot).unwrap(); let bidpot_data = client.get_account(&bidpot).unwrap();

2
rust/metaplex/program/src/processor/redeem_bid.rs
View File

@ -224,7 +224,7 @@ pub fn process_redeem_bid<'a>(
{ {
let master_edition_info = match safety_deposit_config_info { let master_edition_info = match safety_deposit_config_info {
Some(val) => val, Some(val) => val,
None => return Err(ProgramError::NotEnoughAccountKeys) None => return Err(ProgramError::NotEnoughAccountKeys),
}; };
let reservation_list_info = next_account_info(account_info_iter)?; let reservation_list_info = next_account_info(account_info_iter)?;

13
rust/token-metadata/program/src/instruction.rs
View File

@ -314,18 +314,11 @@ pub fn update_metadata_accounts(
} }
/// puff metadata account instruction /// puff metadata account instruction
pub fn puff_metadata_account( pub fn puff_metadata_account(program_id: Pubkey, metadata_account: Pubkey) -> Instruction {
program_id: Pubkey,
metadata_account: Pubkey,
) -> Instruction {
Instruction { Instruction {
program_id, program_id,
accounts: vec![ accounts: vec![AccountMeta::new(metadata_account, false)],
AccountMeta::new(metadata_account, false), data: MetadataInstruction::PuffMetadata.try_to_vec().unwrap(),
],
data: MetadataInstruction::PuffMetadata
.try_to_vec()
.unwrap(),
} }
} }

20
rust/token-metadata/program/src/processor.rs
View File

@ -19,9 +19,9 @@ use {
assert_token_program_matches_package, assert_update_authority_is_correct, assert_token_program_matches_package, assert_update_authority_is_correct,
create_or_allocate_account_raw, get_owner_from_token_account, create_or_allocate_account_raw, get_owner_from_token_account,
process_create_metadata_accounts_logic, process_create_metadata_accounts_logic,
process_mint_new_edition_from_master_edition_via_token_logic, transfer_mint_authority, process_mint_new_edition_from_master_edition_via_token_logic, puff_out_data_fields,
puff_out_data_fields, transfer_mint_authority, CreateMetadataAccountsLogicArgs,
CreateMetadataAccountsLogicArgs, MintNewEditionFromMasterEditionViaTokenLogicArgs, MintNewEditionFromMasterEditionViaTokenLogicArgs,
}, },
}, },
arrayref::array_ref, arrayref::array_ref,
@ -132,10 +132,7 @@ pub fn process_instruction<'a>(
} }
MetadataInstruction::PuffMetadata => { MetadataInstruction::PuffMetadata => {
msg!("Instruction: Puff Metadata"); msg!("Instruction: Puff Metadata");
process_puff_metadata_account( process_puff_metadata_account(program_id, accounts)
program_id,
accounts
)
} }
} }
} }
@ -592,17 +589,16 @@ pub fn process_puff_metadata_account(
assert_owned_by(metadata_account_info, program_id)?; assert_owned_by(metadata_account_info, program_id)?;
puff_out_data_fields(&mut metadata); puff_out_data_fields(&mut metadata);
let edition_seeds = &[ let edition_seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
program_id.as_ref(), program_id.as_ref(),
metadata.mint.as_ref(), metadata.mint.as_ref(),
EDITION.as_bytes() EDITION.as_bytes(),
]; ];
let (_, edition_bump_seed) = let (_, edition_bump_seed) = Pubkey::find_program_address(edition_seeds, program_id);
Pubkey::find_program_address(edition_seeds, program_id);
metadata.edition_nonce = Some(edition_bump_seed); metadata.edition_nonce = Some(edition_bump_seed);
metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?; metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?;
Ok(()) Ok(())
} }

2
rust/token-metadata/program/src/state.rs
View File

@ -100,7 +100,7 @@ pub struct Metadata {
// Whether or not the data struct is mutable, default is not // Whether or not the data struct is mutable, default is not
pub is_mutable: bool, pub is_mutable: bool,
/// nonce for easy calculation of editions, if present /// nonce for easy calculation of editions, if present
pub edition_nonce: Option<u8> pub edition_nonce: Option<u8>,
} }
impl Metadata { impl Metadata {

13
rust/token-metadata/program/src/utils.rs
View File

@ -856,12 +856,11 @@ pub fn process_create_metadata_accounts_logic(
PREFIX.as_bytes(), PREFIX.as_bytes(),
program_id.as_ref(), program_id.as_ref(),
metadata.mint.as_ref(), metadata.mint.as_ref(),
EDITION.as_bytes() EDITION.as_bytes(),
]; ];
let (_, edition_bump_seed) = let (_, edition_bump_seed) = Pubkey::find_program_address(edition_seeds, program_id);
Pubkey::find_program_address(edition_seeds, program_id);
metadata.edition_nonce = Some(edition_bump_seed); metadata.edition_nonce = Some(edition_bump_seed);
metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?; metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?;
Ok(()) Ok(())
@ -872,13 +871,15 @@ pub fn puff_out_data_fields(metadata: &mut Metadata) {
while array_of_zeroes.len() < MAX_NAME_LENGTH - metadata.data.name.len() { while array_of_zeroes.len() < MAX_NAME_LENGTH - metadata.data.name.len() {
array_of_zeroes.push(0u8); array_of_zeroes.push(0u8);
} }
metadata.data.name = metadata.data.name.clone() + std::str::from_utf8(&array_of_zeroes).unwrap(); metadata.data.name =
metadata.data.name.clone() + std::str::from_utf8(&array_of_zeroes).unwrap();
let mut array_of_zeroes = vec![]; let mut array_of_zeroes = vec![];
while array_of_zeroes.len() < MAX_SYMBOL_LENGTH - metadata.data.symbol.len() { while array_of_zeroes.len() < MAX_SYMBOL_LENGTH - metadata.data.symbol.len() {
array_of_zeroes.push(0u8); array_of_zeroes.push(0u8);
} }
metadata.data.symbol = metadata.data.symbol.clone() + std::str::from_utf8(&array_of_zeroes).unwrap(); metadata.data.symbol =
metadata.data.symbol.clone() + std::str::from_utf8(&array_of_zeroes).unwrap();
let mut array_of_zeroes = vec![]; let mut array_of_zeroes = vec![];
while array_of_zeroes.len() < MAX_URI_LENGTH - metadata.data.uri.len() { while array_of_zeroes.len() < MAX_URI_LENGTH - metadata.data.uri.len() {

2
rust/token-metadata/program/tests/utils/edition_marker.rs
View File

@ -98,7 +98,7 @@ impl EditionMarker {
spl_token_vault_id.as_ref(), spl_token_vault_id.as_ref(),
vault_pubkey.as_ref(), vault_pubkey.as_ref(),
]; ];
let (authority, _) = Pubkey::find_program_address(vault_mint_seeds, &spl_token_vault_id); let (_authority, _) = Pubkey::find_program_address(vault_mint_seeds, &spl_token_vault_id);
create_mint(context, &self.mint, &context.payer.pubkey(), None).await?; create_mint(context, &self.mint, &context.payer.pubkey(), None).await?;
create_token_account( create_token_account(

65
rust/token-metadata/test/src/main.rs
View File

@ -23,11 +23,12 @@ use {
spl_token_metadata::{ spl_token_metadata::{
instruction::{ instruction::{
create_master_edition, create_metadata_accounts, create_master_edition, create_metadata_accounts,
mint_new_edition_from_master_edition_via_token, update_metadata_accounts,puff_metadata_account mint_new_edition_from_master_edition_via_token, puff_metadata_account,
update_metadata_accounts,
}, },
state::{ state::{
get_reservation_list, Data, Edition, Key, MasterEditionV1, MasterEditionV2, Metadata, get_reservation_list, Data, Edition, Key, MasterEditionV1, MasterEditionV2, Metadata,
EDITION, PREFIX,MAX_NAME_LENGTH, MAX_URI_LENGTH, MAX_SYMBOL_LENGTH EDITION, MAX_NAME_LENGTH, MAX_SYMBOL_LENGTH, MAX_URI_LENGTH, PREFIX,
}, },
}, },
std::str::FromStr, std::str::FromStr,
@ -35,18 +36,26 @@ use {
const TOKEN_PROGRAM_PUBKEY: &str = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"; const TOKEN_PROGRAM_PUBKEY: &str = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
fn puff_unpuffed_metadata(_app_matches: &ArgMatches, payer: Keypair, client: RpcClient) { fn puff_unpuffed_metadata(_app_matches: &ArgMatches, payer: Keypair, client: RpcClient) {
let metadata_accounts = client.get_program_accounts(&spl_token_metadata::id()).unwrap(); let metadata_accounts = client
.get_program_accounts(&spl_token_metadata::id())
.unwrap();
let mut needing_puffing = vec![]; let mut needing_puffing = vec![];
for acct in metadata_accounts { for acct in metadata_accounts {
if acct.1.data[0] == Key::MetadataV1 as u8 { if acct.1.data[0] == Key::MetadataV1 as u8 {
match try_from_slice_unchecked(&acct.1.data) { match try_from_slice_unchecked(&acct.1.data) {
Ok(val) => { Ok(val) => {
let account: Metadata = val; let account: Metadata = val;
if account.data.name.len() < MAX_NAME_LENGTH || account.data.uri.len() < MAX_URI_LENGTH || account.data.symbol.len() < MAX_SYMBOL_LENGTH || account.edition_nonce.is_none() { if account.data.name.len() < MAX_NAME_LENGTH
|| account.data.uri.len() < MAX_URI_LENGTH
|| account.data.symbol.len() < MAX_SYMBOL_LENGTH
|| account.edition_nonce.is_none()
{
needing_puffing.push(acct.0); needing_puffing.push(acct.0);
} }
}, }
Err(_) => { println!("Skipping {}", acct.0)}, Err(_) => {
println!("Skipping {}", acct.0)
}
}; };
} }
} }
@ -67,11 +76,11 @@ fn puff_unpuffed_metadata(_app_matches: &ArgMatches, payer: Keypair, client: Rpc
println!("Another 20 down. At {} / {}", i, needing_puffing.len()); println!("Another 20 down. At {} / {}", i, needing_puffing.len());
instructions = vec![]; instructions = vec![];
i += 1; i += 1;
}, }
Err(_) => { Err(_) => {
println!("Txn failed. Retry."); println!("Txn failed. Retry.");
std::thread::sleep(std::time::Duration::from_millis(1000)); std::thread::sleep(std::time::Duration::from_millis(1000));
}, }
} }
} else { } else {
i += 1; i += 1;
@ -541,11 +550,7 @@ fn create_metadata_account_call(
Some(_val) => pubkey_of(app_matches, "mint").unwrap(), Some(_val) => pubkey_of(app_matches, "mint").unwrap(),
None => new_mint.pubkey(), None => new_mint.pubkey(),
}; };
let metadata_seeds = &[ let metadata_seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), mint_key.as_ref()];
PREFIX.as_bytes(),
&program_key.as_ref(),
mint_key.as_ref(),
];
let (metadata_key, _) = Pubkey::find_program_address(metadata_seeds, &program_key); let (metadata_key, _) = Pubkey::find_program_address(metadata_seeds, &program_key);
let mut new_mint_instructions = vec![ let mut new_mint_instructions = vec![
@ -568,22 +573,21 @@ fn create_metadata_account_call(
.unwrap(), .unwrap(),
]; ];
let new_metadata_instruction = let new_metadata_instruction = create_metadata_accounts(
create_metadata_accounts( program_key,
program_key, metadata_key,
metadata_key, mint_key,
mint_key, payer.pubkey(),
payer.pubkey(), payer.pubkey(),
payer.pubkey(), update_authority.pubkey(),
update_authority.pubkey(), name,
name, symbol,
symbol, uri,
uri, None,
None, 0,
0, update_authority.pubkey() != payer.pubkey(),
update_authority.pubkey() != payer.pubkey(), mutable,
mutable, );
);
let mut instructions = vec![new_metadata_instruction]; let mut instructions = vec![new_metadata_instruction];
@ -870,7 +874,8 @@ fn main() {
); );
} }
("mint_new_edition_from_master_edition_via_token", Some(arg_matches)) => { ("mint_new_edition_from_master_edition_via_token", Some(arg_matches)) => {
let (edition, edition_key, mint) = mint_edition_via_token_call(arg_matches, payer, client); let (edition, edition_key, mint) =
mint_edition_via_token_call(arg_matches, payer, client);
println!( println!(
"New edition: {:?}\nParent edition: {:?}\nEdition number: {:?}\nToken mint: {:?}", "New edition: {:?}\nParent edition: {:?}\nEdition number: {:?}\nToken mint: {:?}",
edition_key, edition.parent, edition.edition, mint edition_key, edition.parent, edition.edition, mint

10
rust/token-vault/program/src/processor.rs
View File

@ -304,8 +304,8 @@ pub fn process_mint_fractional_shares(
assert_token_program_matches_package(token_program_info)?; assert_token_program_matches_package(token_program_info)?;
assert_token_matching(&vault, token_program_info)?; assert_token_matching(&vault, token_program_info)?;
assert_owned_by(vault_info, program_id)?; assert_owned_by(vault_info, program_id)?;
assert_owned_by(fraction_mint_info, &token_program_info.key)?; assert_owned_by(fraction_mint_info, token_program_info.key)?;
assert_owned_by(fraction_treasury_info, &token_program_info.key)?; assert_owned_by(fraction_treasury_info, token_program_info.key)?;
assert_vault_authority_correct(&vault, vault_authority_info)?; assert_vault_authority_correct(&vault, vault_authority_info)?;
if vault.state != VaultState::Active { if vault.state != VaultState::Active {
@ -849,7 +849,7 @@ pub fn process_add_token_to_inactivated_vault(
let seeds = &[ let seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
&program_id.as_ref(), program_id.as_ref(),
vault_info.key.as_ref(), vault_info.key.as_ref(),
]; ];
let (authority, _) = Pubkey::find_program_address(seeds, program_id); let (authority, _) = Pubkey::find_program_address(seeds, program_id);
@ -964,10 +964,10 @@ pub fn process_init_vault(
let seeds = &[ let seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
&program_id.as_ref(), program_id.as_ref(),
vault_info.key.as_ref(), vault_info.key.as_ref(),
]; ];
let (authority, _) = Pubkey::find_program_address(seeds, &program_id); let (authority, _) = Pubkey::find_program_address(seeds, program_id);
match fraction_mint.mint_authority { match fraction_mint.mint_authority {
solana_program::program_option::COption::None => { solana_program::program_option::COption::None => {

8
rust/token-vault/program/src/utils.rs
View File

@ -97,7 +97,7 @@ pub fn create_or_allocate_account_raw<'a>(
if required_lamports > 0 { if required_lamports > 0 {
msg!("Transfer {} lamports to the new account", required_lamports); msg!("Transfer {} lamports to the new account", required_lamports);
invoke( invoke(
&system_instruction::transfer(&payer_info.key, new_account_info.key, required_lamports), &system_instruction::transfer(payer_info.key, new_account_info.key, required_lamports),
&[ &[
payer_info.clone(), payer_info.clone(),
new_account_info.clone(), new_account_info.clone(),
@ -110,14 +110,14 @@ pub fn create_or_allocate_account_raw<'a>(
invoke_signed( invoke_signed(
&system_instruction::allocate(new_account_info.key, size.try_into().unwrap()), &system_instruction::allocate(new_account_info.key, size.try_into().unwrap()),
&[new_account_info.clone(), system_program_info.clone()], &[new_account_info.clone(), system_program_info.clone()],
&[&signer_seeds], &[signer_seeds],
)?; )?;
msg!("Assign the account to the owning program"); msg!("Assign the account to the owning program");
invoke_signed( invoke_signed(
&system_instruction::assign(new_account_info.key, &program_id), &system_instruction::assign(new_account_info.key, &program_id),
&[new_account_info.clone(), system_program_info.clone()], &[new_account_info.clone(), system_program_info.clone()],
&[&signer_seeds], &[signer_seeds],
)?; )?;
msg!("Completed assignation!"); msg!("Completed assignation!");
@ -268,7 +268,7 @@ pub fn assert_derivation(
account: &AccountInfo, account: &AccountInfo,
path: &[&[u8]], path: &[&[u8]],
) -> Result<u8, ProgramError> { ) -> Result<u8, ProgramError> {
let (key, bump) = Pubkey::find_program_address(&path, program_id); let (key, bump) = Pubkey::find_program_address(path, program_id);
if key != *account.key { if key != *account.key {
return Err(VaultError::DerivedKeyInvalid.into()); return Err(VaultError::DerivedKeyInvalid.into());
} }

20
rust/token-vault/test/src/main.rs
View File

@ -50,7 +50,7 @@ fn initialize_vault(app_matches: &ArgMatches, payer: Keypair, client: RpcClient)
let vault = Keypair::new(); let vault = Keypair::new();
let allow_further_share_creation = app_matches.is_present("allow_further_share_creation"); let allow_further_share_creation = app_matches.is_present("allow_further_share_creation");
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (authority, _) = Pubkey::find_program_address(seeds, &program_key); let (authority, _) = Pubkey::find_program_address(seeds, &program_key);
let instructions = [ let instructions = [
@ -241,11 +241,11 @@ fn add_token_to_vault(app_matches: &ArgMatches, payer: Keypair, client: RpcClien
let clone_of_key = token_mint.pubkey().clone(); let clone_of_key = token_mint.pubkey().clone();
let seeds = &[ let seeds = &[
PREFIX.as_bytes(), PREFIX.as_bytes(),
&vault_key.as_ref(), vault_key.as_ref(),
&clone_of_key.as_ref(), clone_of_key.as_ref(),
]; ];
let (safety_deposit_box, _) = Pubkey::find_program_address(seeds, &program_key); let (safety_deposit_box, _) = Pubkey::find_program_address(seeds, &program_key);
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (authority, _) = Pubkey::find_program_address(seeds, &program_key); let (authority, _) = Pubkey::find_program_address(seeds, &program_key);
let instructions = [ let instructions = [
@ -364,7 +364,7 @@ fn activate_vault(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) -
let vault_account = client.get_account(&vault_key).unwrap(); let vault_account = client.get_account(&vault_key).unwrap();
let vault: Vault = try_from_slice_unchecked(&vault_account.data).unwrap(); let vault: Vault = try_from_slice_unchecked(&vault_account.data).unwrap();
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (mint_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (mint_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let instructions = [create_activate_vault_instruction( let instructions = [create_activate_vault_instruction(
@ -422,7 +422,7 @@ fn combine_vault(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) ->
try_from_slice_unchecked(&external_price_account.data).unwrap(); try_from_slice_unchecked(&external_price_account.data).unwrap();
let payment_account = Keypair::new(); let payment_account = Keypair::new();
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (uncirculated_burn_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (uncirculated_burn_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let transfer_authority = Keypair::new(); let transfer_authority = Keypair::new();
@ -572,7 +572,7 @@ fn redeem_shares(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) ->
let burn_authority = Keypair::new(); let burn_authority = Keypair::new();
let mut signers = vec![&payer, &vault_authority, &burn_authority]; let mut signers = vec![&payer, &vault_authority, &burn_authority];
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let mut instructions = vec![]; let mut instructions = vec![];
@ -662,7 +662,7 @@ fn withdraw_tokens(app_matches: &ArgMatches, payer: Keypair, client: RpcClient)
.unwrap(); .unwrap();
let mut signers = vec![&payer, &vault_authority]; let mut signers = vec![&payer, &vault_authority];
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let mut instructions = vec![]; let mut instructions = vec![];
@ -725,7 +725,7 @@ fn mint_shares(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) -> P
let vault: Vault = try_from_slice_unchecked(&vault_account.data).unwrap(); let vault: Vault = try_from_slice_unchecked(&vault_account.data).unwrap();
let signers = vec![&payer, &vault_authority]; let signers = vec![&payer, &vault_authority];
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (mint_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (mint_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let number_of_shares: u64 = app_matches let number_of_shares: u64 = app_matches
@ -774,7 +774,7 @@ fn withdraw_shares(app_matches: &ArgMatches, payer: Keypair, client: RpcClient)
.unwrap(); .unwrap();
let mut signers = vec![&payer, &vault_authority]; let mut signers = vec![&payer, &vault_authority];
let seeds = &[PREFIX.as_bytes(), &program_key.as_ref()]; let seeds = &[PREFIX.as_bytes(), program_key.as_ref()];
let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key); let (transfer_authority, _) = Pubkey::find_program_address(seeds, &program_key);
let mut instructions = vec![]; let mut instructions = vec![];