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

token: Simplify initialize_mint (#327) 

* Simplify initialize_mint

* C headers
This commit is contained in:
Tyera Eulberg 2020-08-26 18:27:44 -06:00 committed by GitHub
parent 9b59d4e52e
commit ea52428475
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 155 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
token/program2/inc/token2.h
View File

@ -118,7 +118,6 @@ typedef enum Token_TokenInstruction_Tag {
* Accounts expected by this instruction: * Accounts expected by this instruction:
* *
* 0. `[writable]` The mint to initialize. * 0. `[writable]` The mint to initialize.
* 1. If supply is non-zero: `[writable]` The account to hold all the newly minted tokens.
* *
*/ */
Token_TokenInstruction_InitializeMint, Token_TokenInstruction_InitializeMint,
@ -308,17 +307,12 @@ typedef enum Token_TokenInstruction_Tag {
} Token_TokenInstruction_Tag; } Token_TokenInstruction_Tag;
typedef struct Token_TokenInstruction_Token_InitializeMint_Body { typedef struct Token_TokenInstruction_Token_InitializeMint_Body {
/**
* Initial amount of tokens to mint.
*/
uint64_t amount;
/** /**
* Number of base 10 digits to the right of the decimal place. * Number of base 10 digits to the right of the decimal place.
*/ */
uint8_t decimals; uint8_t decimals;
/** /**
* The authority/multisignature to mint tokens, if supply is non-zero. If present, * The authority/multisignature to mint tokens. If present, further minting is supported.
* further minting is supported.
*/ */
Token_COption_Pubkey mint_authority; Token_COption_Pubkey mint_authority;
/** /**

43
token/program2/src/instruction.rs
View File

@ -26,15 +26,11 @@ pub enum TokenInstruction {
/// Accounts expected by this instruction: /// Accounts expected by this instruction:
/// ///
/// 0. `[writable]` The mint to initialize. /// 0. `[writable]` The mint to initialize.
/// 1. If supply is non-zero: `[writable]` The account to hold all the newly minted tokens.
/// ///
InitializeMint { InitializeMint {
/// Initial amount of tokens to mint.
amount: u64,
/// Number of base 10 digits to the right of the decimal place. /// Number of base 10 digits to the right of the decimal place.
decimals: u8, decimals: u8,
/// The authority/multisignature to mint tokens, if supply is non-zero. If present, /// The authority/multisignature to mint tokens. If present, further minting is supported.
/// further minting is supported.
mint_authority: COption<Pubkey>, mint_authority: COption<Pubkey>,
/// The freeze authority/multisignature of the mint. /// The freeze authority/multisignature of the mint.
freeze_authority: COption<Pubkey>, freeze_authority: COption<Pubkey>,
@ -230,17 +226,12 @@ impl TokenInstruction {
} }
Ok(match input[0] { Ok(match input[0] {
0 => { 0 => {
if input.len() if input.len() < size_of::<u8>() + size_of::<u8>() + size_of::<bool>() {
< size_of::<u8>() + size_of::<u64>() + size_of::<u8>() + size_of::<bool>()
{
return Err(TokenError::InvalidInstruction.into()); return Err(TokenError::InvalidInstruction.into());
} }
let mut input_len = 0; let mut input_len = 0;
input_len += size_of::<u8>(); input_len += size_of::<u8>();
#[allow(clippy::cast_ptr_alignment)]
let amount = unsafe { *(&input[input_len] as *const u8 as *const u64) };
input_len += size_of::<u64>();
let decimals = unsafe { *(&input[input_len] as *const u8) }; let decimals = unsafe { *(&input[input_len] as *const u8) };
input_len += size_of::<u8>(); input_len += size_of::<u8>();
@ -258,7 +249,6 @@ impl TokenInstruction {
Self::InitializeMint { Self::InitializeMint {
mint_authority, mint_authority,
freeze_authority, freeze_authority,
amount,
decimals, decimals,
} }
} }
@ -339,17 +329,11 @@ impl TokenInstruction {
Self::InitializeMint { Self::InitializeMint {
mint_authority, mint_authority,
freeze_authority, freeze_authority,
amount,
decimals, decimals,
} => { } => {
output[output_len] = 0; output[output_len] = 0;
output_len += size_of::<u8>(); output_len += size_of::<u8>();
#[allow(clippy::cast_ptr_alignment)]
let value = unsafe { &mut *(&mut output[output_len] as *mut u8 as *mut u64) };
*value = *amount;
output_len += size_of::<u64>();
let value = unsafe { &mut *(&mut output[output_len] as *mut u8) }; let value = unsafe { &mut *(&mut output[output_len] as *mut u8) };
*value = *decimals; *value = *decimals;
output_len += size_of::<u8>(); output_len += size_of::<u8>();
@ -480,31 +464,20 @@ impl AuthorityType {
pub fn initialize_mint( pub fn initialize_mint(
token_program_id: &Pubkey, token_program_id: &Pubkey,
mint_pubkey: &Pubkey, mint_pubkey: &Pubkey,
account_pubkey: Option<&Pubkey>, mint_authority_pubkey: &Pubkey,
mint_authority_pubkey: Option<&Pubkey>,
freeze_authority_pubkey: Option<&Pubkey>, freeze_authority_pubkey: Option<&Pubkey>,
amount: u64,
decimals: u8, decimals: u8,
) -> Result<Instruction, ProgramError> { ) -> Result<Instruction, ProgramError> {
let mint_authority = mint_authority_pubkey.cloned().into(); let mint_authority = COption::Some(*mint_authority_pubkey);
let freeze_authority = freeze_authority_pubkey.cloned().into(); let freeze_authority = freeze_authority_pubkey.cloned().into();
let data = TokenInstruction::InitializeMint { let data = TokenInstruction::InitializeMint {
mint_authority, mint_authority,
freeze_authority, freeze_authority,
amount,
decimals, decimals,
} }
.pack()?; .pack()?;
let mut accounts = vec![AccountMeta::new(*mint_pubkey, false)]; let accounts = vec![AccountMeta::new(*mint_pubkey, false)];
if amount != 0 {
match account_pubkey {
Some(pubkey) => accounts.push(AccountMeta::new(*pubkey, false)),
None => {
return Err(ProgramError::NotEnoughAccountKeys);
}
}
}
Ok(Instruction { Ok(Instruction {
program_id: *token_program_id, program_id: *token_program_id,
@ -832,25 +805,23 @@ mod test {
#[test] #[test]
fn test_instruction_packing() { fn test_instruction_packing() {
let check = TokenInstruction::InitializeMint { let check = TokenInstruction::InitializeMint {
amount: 1,
decimals: 2, decimals: 2,
mint_authority: COption::None, mint_authority: COption::None,
freeze_authority: COption::None, freeze_authority: COption::None,
}; };
let packed = check.pack().unwrap(); let packed = check.pack().unwrap();
let expect = Vec::from([0u8, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0]); let expect = Vec::from([0u8, 2, 0, 0]);
assert_eq!(packed, expect); assert_eq!(packed, expect);
let unpacked = TokenInstruction::unpack(&expect).unwrap(); let unpacked = TokenInstruction::unpack(&expect).unwrap();
assert_eq!(unpacked, check); assert_eq!(unpacked, check);
let check = TokenInstruction::InitializeMint { let check = TokenInstruction::InitializeMint {
amount: 1,
decimals: 2, decimals: 2,
mint_authority: COption::Some(Pubkey::new(&[2u8; 32])), mint_authority: COption::Some(Pubkey::new(&[2u8; 32])),
freeze_authority: COption::Some(Pubkey::new(&[3u8; 32])), freeze_authority: COption::Some(Pubkey::new(&[3u8; 32])),
}; };
let packed = check.pack().unwrap(); let packed = check.pack().unwrap();
let mut expect = vec![0u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]; let mut expect = vec![0u8, 2];
expect.extend_from_slice(&[1]); expect.extend_from_slice(&[1]);
expect.extend_from_slice(&[2u8; 32]); expect.extend_from_slice(&[2u8; 32]);
expect.extend_from_slice(&[1]); expect.extend_from_slice(&[1]);

414
token/program2/src/processor.rs
View File

@ -25,7 +25,6 @@ impl Processor {
/// Processes an [InitializeMint](enum.TokenInstruction.html) instruction. /// Processes an [InitializeMint](enum.TokenInstruction.html) instruction.
pub fn process_initialize_mint( pub fn process_initialize_mint(
accounts: &[AccountInfo], accounts: &[AccountInfo],
amount: u64,
decimals: u8, decimals: u8,
mint_authority: COption<Pubkey>, mint_authority: COption<Pubkey>,
freeze_authority: COption<Pubkey>, freeze_authority: COption<Pubkey>,
@ -39,17 +38,7 @@ impl Processor {
return Err(TokenError::AlreadyInUse.into()); return Err(TokenError::AlreadyInUse.into());
} }
if amount != 0 { if mint_authority.is_none() {
let dest_account_info = next_account_info(account_info_iter)?;
let mut dest_account_data = dest_account_info.data.borrow_mut();
let mut dest_account: &mut Account = state::unpack(&mut dest_account_data)?;
if mint_info.key != &dest_account.mint {
return Err(TokenError::MintMismatch.into());
}
dest_account.amount = amount;
} else if mint_authority.is_none() {
return Err(TokenError::OwnerRequiredIfNoInitialSupply.into()); return Err(TokenError::OwnerRequiredIfNoInitialSupply.into());
} }
@ -525,19 +514,12 @@ impl Processor {
match instruction { match instruction {
TokenInstruction::InitializeMint { TokenInstruction::InitializeMint {
amount,
decimals, decimals,
mint_authority, mint_authority,
freeze_authority, freeze_authority,
} => { } => {
info!("Instruction: InitializeMint"); info!("Instruction: InitializeMint");
Self::process_initialize_mint( Self::process_initialize_mint(accounts, decimals, mint_authority, freeze_authority)
accounts,
amount,
decimals,
mint_authority,
freeze_authority,
)
} }
TokenInstruction::InitializeAccount => { TokenInstruction::InitializeAccount => {
info!("Instruction: InitializeAccount"); info!("Instruction: InitializeAccount");
@ -726,125 +708,46 @@ mod tests {
#[test] #[test]
fn test_initialize_mint() { fn test_initialize_mint() {
let program_id = pubkey_rand(); let program_id = pubkey_rand();
let account_key = pubkey_rand();
let mut account_account = SolanaAccount::new(0, size_of::<Account>(), &program_id);
let account2_key = pubkey_rand();
let mut account2_account = SolanaAccount::new(0, size_of::<Account>(), &program_id);
let owner_key = pubkey_rand(); let owner_key = pubkey_rand();
let mut owner_account = SolanaAccount::default();
let mint_key = pubkey_rand(); let mint_key = pubkey_rand();
let mut mint_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id); let mut mint_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id);
let mint2_key = pubkey_rand(); let mint2_key = pubkey_rand();
let mut mint2_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id); let mut mint2_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id);
// account not created // mint_authority not provided
assert_eq!( let mut instruction = initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap();
Err(TokenError::UninitializedState.into()), instruction.data = TokenInstruction::InitializeMint {
do_process_instruction( mint_authority: COption::None,
initialize_mint( freeze_authority: COption::None,
&program_id, decimals: 2,
&mint_key, }
Some(&account_key), .pack()
None,
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account]
)
);
// create account
do_process_instruction(
initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
vec![&mut account_account, &mut owner_account, &mut mint_account],
)
.unwrap(); .unwrap();
assert_eq!(
Err(TokenError::OwnerRequiredIfNoInitialSupply.into()),
do_process_instruction(instruction, vec![&mut mint_account])
);
// create new mint // create new mint
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account],
) )
.unwrap(); .unwrap();
// create another account
do_process_instruction(
initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
vec![&mut account2_account, &mut owner_account, &mut mint_account],
)
.unwrap();
// mismatch account
assert_eq!(
Err(TokenError::MintMismatch.into()),
do_process_instruction(
initialize_mint(
&program_id,
&mint2_key,
Some(&account2_key),
None,
None,
1000,
2,
)
.unwrap(),
vec![&mut mint2_account, &mut account2_account]
)
);
// create twice // create twice
assert_eq!( assert_eq!(
Err(TokenError::AlreadyInUse.into()), Err(TokenError::AlreadyInUse.into()),
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2,).unwrap(),
&program_id, vec![&mut mint_account]
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account]
) )
); );
// create another mint that can freeze // create another mint that can freeze
let account3_key = pubkey_rand();
let mut account3_account = SolanaAccount::new(0, size_of::<Account>(), &program_id);
do_process_instruction( do_process_instruction(
initialize_account(&program_id, &account3_key, &mint2_key, &owner_key).unwrap(), initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
vec![ vec![&mut mint2_account],
&mut account3_account,
&mut owner_account,
&mut mint2_account,
],
)
.unwrap();
do_process_instruction(
initialize_mint(
&program_id,
&mint2_key,
Some(&account3_key),
Some(&owner_key),
Some(&owner_key),
1000,
2,
)
.unwrap(),
vec![&mut mint2_account, &mut account3_account],
) )
.unwrap(); .unwrap();
let mint2: &mut Mint = state::unpack(&mut mint2_account.data).unwrap(); let mint2: &mut Mint = state::unpack(&mut mint2_account.data).unwrap();
@ -932,19 +835,15 @@ mod tests {
) )
.unwrap(); .unwrap();
// create new mint // create new mint & mint to account
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
) )
.unwrap(), .unwrap();
vec![&mut mint_account, &mut account_account], do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -1267,30 +1166,11 @@ mod tests {
) )
.unwrap(); .unwrap();
// create mint-able token without owner
assert_eq!(
Err(TokenError::OwnerRequiredIfNoInitialSupply.into()),
do_process_instruction(
initialize_mint(&program_id, &mint_key, None, None, None, 0, 2,).unwrap(),
vec![&mut mint_account]
)
);
// create mint-able token with zero supply // create mint-able token with zero supply
let amount = 0;
let decimals = 2; let decimals = 2;
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, decimals).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
None,
Some(&owner_key),
None,
amount,
decimals,
)
.unwrap(),
vec![&mut mint_account, &mut account_account],
) )
.unwrap(); .unwrap();
let mint: &mut Mint = state::unpack(&mut mint_account.data).unwrap(); let mint: &mut Mint = state::unpack(&mut mint_account.data).unwrap();
@ -1346,21 +1226,17 @@ mod tests {
) )
.unwrap(); .unwrap();
// create new mint // create new mint & mint to account
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id,
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account], vec![&mut mint_account, &mut account_account],
) )
.unwrap(); .unwrap();
do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account],
)
.unwrap();
// missing signer // missing signer
let mut instruction = approve( let mut instruction = approve(
@ -1449,8 +1325,6 @@ mod tests {
let mut mint_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id); let mut mint_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id);
let mint2_key = pubkey_rand(); let mint2_key = pubkey_rand();
let mut mint2_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id); let mut mint2_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id);
let mint3_key = pubkey_rand();
let mut mint3_account = SolanaAccount::new(0, size_of::<Mint>(), &program_id);
// invalid account // invalid account
assert_eq!( assert_eq!(
@ -1601,21 +1475,12 @@ mod tests {
// create new mint with owner // create new mint with owner
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
Some(&owner_key),
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account],
) )
.unwrap(); .unwrap();
// wrong account // wrong owner
assert_eq!( assert_eq!(
Err(TokenError::OwnerMismatch.into()), Err(TokenError::OwnerMismatch.into()),
do_process_instruction( do_process_instruction(
@ -1680,25 +1545,24 @@ mod tests {
) )
.unwrap(); .unwrap();
// create new mint without owner // set owner to None
do_process_instruction( do_process_instruction(
initialize_mint( set_authority(
&program_id, &program_id,
&mint2_key, &mint_key,
Some(&account2_key),
None, None,
None, AuthorityType::MintTokens,
1000, &owner2_key,
2, &[],
) )
.unwrap(), .unwrap(),
vec![&mut mint2_account, &mut account2_account], vec![&mut mint_account, &mut owner2_account],
) )
.unwrap(); .unwrap();
// set owner for non-mint-able token // test unsetting mint_authority is one-way operation
assert_eq!( assert_eq!(
Err(TokenError::OwnerMismatch.into()), Err(TokenError::FixedSupply.into()),
do_process_instruction( do_process_instruction(
set_authority( set_authority(
&program_id, &program_id,
@ -1715,17 +1579,8 @@ mod tests {
// create mint with owner and freeze_authority // create mint with owner and freeze_authority
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
&program_id, vec![&mut mint2_account],
&mint3_key,
None,
Some(&owner_key),
Some(&owner_key),
0,
2,
)
.unwrap(),
vec![&mut mint3_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -1733,14 +1588,14 @@ mod tests {
do_process_instruction( do_process_instruction(
set_authority( set_authority(
&program_id, &program_id,
&mint3_key, &mint2_key,
Some(&owner2_key), Some(&owner2_key),
AuthorityType::FreezeAccount, AuthorityType::FreezeAccount,
&owner_key, &owner_key,
&[], &[],
) )
.unwrap(), .unwrap(),
vec![&mut mint3_account, &mut owner_account], vec![&mut mint2_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -1748,14 +1603,14 @@ mod tests {
do_process_instruction( do_process_instruction(
set_authority( set_authority(
&program_id, &program_id,
&mint3_key, &mint2_key,
None, None,
AuthorityType::FreezeAccount, AuthorityType::FreezeAccount,
&owner2_key, &owner2_key,
&[], &[],
) )
.unwrap(), .unwrap(),
vec![&mut mint3_account, &mut owner2_account], vec![&mut mint2_account, &mut owner2_account],
) )
.unwrap(); .unwrap();
@ -1764,14 +1619,14 @@ mod tests {
do_process_instruction( do_process_instruction(
set_authority( set_authority(
&program_id, &program_id,
&mint3_key, &mint2_key,
Some(&owner2_key), Some(&owner2_key),
AuthorityType::FreezeAccount, AuthorityType::FreezeAccount,
&owner_key, &owner_key,
&[], &[],
) )
.unwrap(), .unwrap(),
vec![&mut mint_account, &mut owner2_account], vec![&mut mint2_account, &mut owner2_account],
) )
); );
} }
@ -1832,17 +1687,8 @@ mod tests {
// create new mint with owner // create new mint with owner
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
Some(&owner_key),
None,
1000,
2,
)
.unwrap(),
vec![&mut mint_account, &mut account_account],
) )
.unwrap(); .unwrap();
@ -1911,6 +1757,28 @@ mod tests {
], ],
) )
); );
// unset mint_authority and test minting fails
do_process_instruction(
set_authority(
&program_id,
&mint_key,
None,
AuthorityType::MintTokens,
&owner_key,
&[],
)
.unwrap(),
vec![&mut mint_account, &mut owner_account],
)
.unwrap();
assert_eq!(
Err(TokenError::FixedSupply.into()),
do_process_instruction(
mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(),
vec![&mut mint_account, &mut account2_account, &mut owner_account],
)
);
} }
#[test] #[test]
@ -1969,17 +1837,13 @@ mod tests {
// create new mint // create new mint
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
) )
.unwrap(), .unwrap();
vec![&mut mint_account, &mut account_account], do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -2157,17 +2021,27 @@ mod tests {
// create new mint with multisig owner // create new mint with multisig owner
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &multisig_key, None, 2).unwrap(),
vec![&mut mint_account],
)
.unwrap();
let account_info_iter = &mut signer_accounts.iter_mut();
do_process_instruction(
mint_to(
&program_id, &program_id,
&mint_key, &mint_key,
Some(&account_key), &account_key,
Some(&multisig_key), &multisig_key,
None, &[&signer_keys[0]],
1000, 1000,
2,
) )
.unwrap(), .unwrap(),
vec![&mut mint_account, &mut account], vec![
&mut mint_account,
&mut account,
&mut multisig_account,
&mut account_info_iter.next().unwrap(),
],
) )
.unwrap(); .unwrap();
@ -2331,14 +2205,31 @@ mod tests {
initialize_mint( initialize_mint(
&program_id, &program_id,
&mint2_key, &mint2_key,
Some(&account3_key), &multisig_key,
None,
Some(&multisig_key), Some(&multisig_key),
1000,
2, 2,
) )
.unwrap(), .unwrap(),
vec![&mut mint2_account, &mut account3_account], vec![&mut mint2_account],
)
.unwrap();
let account_info_iter = &mut signer_accounts.iter_mut();
do_process_instruction(
mint_to(
&program_id,
&mint2_key,
&account3_key,
&multisig_key,
&[&signer_keys[0]],
1000,
)
.unwrap(),
vec![
&mut mint2_account,
&mut account3_account,
&mut multisig_account,
&mut account_info_iter.next().unwrap(),
],
) )
.unwrap(); .unwrap();
let account_info_iter = &mut signer_accounts.iter_mut(); let account_info_iter = &mut signer_accounts.iter_mut();
@ -2561,16 +2452,12 @@ mod tests {
) )
.unwrap(); .unwrap();
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account, &mut account_account, &mut owner_account],
&mint_key,
Some(&account_key),
None,
None,
42,
2,
) )
.unwrap(), .unwrap();
do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account], vec![&mut mint_account, &mut account_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -2864,17 +2751,8 @@ mod tests {
// create new mint with owner // create new mint with owner
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &mint_owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
None,
Some(&mint_owner_key),
None,
0,
2,
)
.unwrap(),
vec![&mut mint_account, &mut mint_owner_account],
) )
.unwrap(); .unwrap();
@ -3014,17 +2892,13 @@ mod tests {
// create new mint and fund first account // create new mint and fund first account
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
None,
None,
1000,
2,
) )
.unwrap(), .unwrap();
vec![&mut mint_account, &mut account_account], do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account],
) )
.unwrap(); .unwrap();
@ -3176,17 +3050,13 @@ mod tests {
// create new mint with owner different from account owner // create new mint with owner different from account owner
do_process_instruction( do_process_instruction(
initialize_mint( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
&program_id, vec![&mut mint_account],
&mint_key,
Some(&account_key),
Some(&owner_key),
None,
1000,
2,
) )
.unwrap(), .unwrap();
vec![&mut mint_account, &mut account_account], do_process_instruction(
mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
vec![&mut mint_account, &mut account_account, &mut owner_account],
) )
.unwrap(); .unwrap();