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();
// 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);
// 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();
// 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);
// 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();
// 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 bidder_pubkey = bidder.pubkey();
let seeds = &[
PREFIX.as_bytes(),
&program_key.as_ref(),
&auction.as_ref(),
&bidder_pubkey.as_ref(),
program_key.as_ref(),
auction.as_ref(),
bidder_pubkey.as_ref(),
];
let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key);
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();
// 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 bidder_pubkey = bidder.pubkey();
let seeds = &[
PREFIX.as_bytes(),
&program_key.as_ref(),
&auction.as_ref(),
&bidder_pubkey.as_ref(),
program_key.as_ref(),
auction.as_ref(),
bidder_pubkey.as_ref(),
];
let (bidpot, _) = Pubkey::find_program_address(seeds, &program_key);
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 {
Some(val) => val,
None => return Err(ProgramError::NotEnoughAccountKeys)
None => return Err(ProgramError::NotEnoughAccountKeys),
};
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
pub fn puff_metadata_account(
program_id: Pubkey,
metadata_account: Pubkey,
) -> Instruction {
pub fn puff_metadata_account(program_id: Pubkey, metadata_account: Pubkey) -> Instruction {
Instruction {
program_id,
accounts: vec![
AccountMeta::new(metadata_account, false),
],
data: MetadataInstruction::PuffMetadata
.try_to_vec()
.unwrap(),
accounts: vec![AccountMeta::new(metadata_account, false)],
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,
create_or_allocate_account_raw, get_owner_from_token_account,
process_create_metadata_accounts_logic,
process_mint_new_edition_from_master_edition_via_token_logic, transfer_mint_authority,
puff_out_data_fields,
CreateMetadataAccountsLogicArgs, MintNewEditionFromMasterEditionViaTokenLogicArgs,
process_mint_new_edition_from_master_edition_via_token_logic, puff_out_data_fields,
transfer_mint_authority, CreateMetadataAccountsLogicArgs,
MintNewEditionFromMasterEditionViaTokenLogicArgs,
},
},
arrayref::array_ref,
@ -132,10 +132,7 @@ pub fn process_instruction<'a>(
}
MetadataInstruction::PuffMetadata => {
msg!("Instruction: Puff Metadata");
process_puff_metadata_account(
program_id,
accounts
)
process_puff_metadata_account(program_id, accounts)
}
}
}
@ -592,17 +589,16 @@ pub fn process_puff_metadata_account(
assert_owned_by(metadata_account_info, program_id)?;
puff_out_data_fields(&mut metadata);
let edition_seeds = &[
PREFIX.as_bytes(),
program_id.as_ref(),
metadata.mint.as_ref(),
EDITION.as_bytes()
EDITION.as_bytes(),
];
let (_, edition_bump_seed) =
Pubkey::find_program_address(edition_seeds, program_id);
let (_, edition_bump_seed) = Pubkey::find_program_address(edition_seeds, program_id);
metadata.edition_nonce = Some(edition_bump_seed);
metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?;
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
pub is_mutable: bool,
/// nonce for easy calculation of editions, if present
pub edition_nonce: Option<u8>
pub edition_nonce: Option<u8>,
}
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(),
program_id.as_ref(),
metadata.mint.as_ref(),
EDITION.as_bytes()
EDITION.as_bytes(),
];
let (_, edition_bump_seed) =
Pubkey::find_program_address(edition_seeds, program_id);
let (_, edition_bump_seed) = Pubkey::find_program_address(edition_seeds, program_id);
metadata.edition_nonce = Some(edition_bump_seed);
metadata.serialize(&mut *metadata_account_info.data.borrow_mut())?;
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() {
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![];
while array_of_zeroes.len() < MAX_SYMBOL_LENGTH - metadata.data.symbol.len() {
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![];
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(),
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_token_account(

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

@ -23,11 +23,12 @@ use {
spl_token_metadata::{
instruction::{
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::{
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,
@ -35,18 +36,26 @@ use {
const TOKEN_PROGRAM_PUBKEY: &str = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
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![];
for acct in metadata_accounts {
if acct.1.data[0] == Key::MetadataV1 as u8 {
match try_from_slice_unchecked(&acct.1.data) {
Ok(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);
}
},
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());
instructions = vec![];
i += 1;
},
}
Err(_) => {
println!("Txn failed. Retry.");
std::thread::sleep(std::time::Duration::from_millis(1000));
},
}
}
} else {
i += 1;
@ -541,11 +550,7 @@ fn create_metadata_account_call(
Some(_val) => pubkey_of(app_matches, "mint").unwrap(),
None => new_mint.pubkey(),
};
let metadata_seeds = &[
PREFIX.as_bytes(),
&program_key.as_ref(),
mint_key.as_ref(),
];
let metadata_seeds = &[PREFIX.as_bytes(), &program_key.as_ref(), mint_key.as_ref()];
let (metadata_key, _) = Pubkey::find_program_address(metadata_seeds, &program_key);
let mut new_mint_instructions = vec![
@ -568,22 +573,21 @@ fn create_metadata_account_call(
.unwrap(),
];
let new_metadata_instruction =
create_metadata_accounts(
program_key,
metadata_key,
mint_key,
payer.pubkey(),
payer.pubkey(),
update_authority.pubkey(),
name,
symbol,
uri,
None,
0,
update_authority.pubkey() != payer.pubkey(),
mutable,
);
let new_metadata_instruction = create_metadata_accounts(
program_key,
metadata_key,
mint_key,
payer.pubkey(),
payer.pubkey(),
update_authority.pubkey(),
name,
symbol,
uri,
None,
0,
update_authority.pubkey() != payer.pubkey(),
mutable,
);
let mut instructions = vec![new_metadata_instruction];
@ -870,7 +874,8 @@ fn main() {
);
}
("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!(
"New edition: {:?}\nParent edition: {:?}\nEdition number: {:?}\nToken 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_matching(&vault, token_program_info)?;
assert_owned_by(vault_info, program_id)?;
assert_owned_by(fraction_mint_info, &token_program_info.key)?;
assert_owned_by(fraction_treasury_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_vault_authority_correct(&vault, vault_authority_info)?;
if vault.state != VaultState::Active {
@ -849,7 +849,7 @@ pub fn process_add_token_to_inactivated_vault(
let seeds = &[
PREFIX.as_bytes(),
&program_id.as_ref(),
program_id.as_ref(),
vault_info.key.as_ref(),
];
let (authority, _) = Pubkey::find_program_address(seeds, program_id);
@ -964,10 +964,10 @@ pub fn process_init_vault(
let seeds = &[
PREFIX.as_bytes(),
&program_id.as_ref(),
program_id.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 {
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 {
msg!("Transfer {} lamports to the new account", required_lamports);
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(),
new_account_info.clone(),
@ -110,14 +110,14 @@ pub fn create_or_allocate_account_raw<'a>(
invoke_signed(
&system_instruction::allocate(new_account_info.key, size.try_into().unwrap()),
&[new_account_info.clone(), system_program_info.clone()],
&[&signer_seeds],
&[signer_seeds],
)?;
msg!("Assign the account to the owning program");
invoke_signed(
&system_instruction::assign(new_account_info.key, &program_id),
&[new_account_info.clone(), system_program_info.clone()],
&[&signer_seeds],
&[signer_seeds],
)?;
msg!("Completed assignation!");
@ -268,7 +268,7 @@ pub fn assert_derivation(
account: &AccountInfo,
path: &[&[u8]],
) -> 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 {
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 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 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 seeds = &[
PREFIX.as_bytes(),
&vault_key.as_ref(),
&clone_of_key.as_ref(),
vault_key.as_ref(),
clone_of_key.as_ref(),
];
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 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: 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 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();
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 transfer_authority = Keypair::new();
@ -572,7 +572,7 @@ fn redeem_shares(app_matches: &ArgMatches, payer: Keypair, client: RpcClient) ->
let burn_authority = Keypair::new();
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 mut instructions = vec![];
@ -662,7 +662,7 @@ fn withdraw_tokens(app_matches: &ArgMatches, payer: Keypair, client: RpcClient)
.unwrap();
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 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 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 number_of_shares: u64 = app_matches
@ -774,7 +774,7 @@ fn withdraw_shares(app_matches: &ArgMatches, payer: Keypair, client: RpcClient)
.unwrap();
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 mut instructions = vec![];