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

require `to` account signature (#6658) 

* require to signature

* fixing invocation to create_account

* fix create_account references

* address review comment

* whacking bugs in tests

* fixing stake program tests
This commit is contained in:
Parth 2019-11-08 15:57:35 +05:30 committed by GitHub
parent f7b6e777bf
commit 5bd05fba09
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 277 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
bench-exchange/src/bench.rs
View File

@ -178,19 +178,28 @@ where
info!("Generating {:?} account keys", total_keys);
let mut account_keypairs = generate_keypairs(total_keys);
let src_pubkeys: Vec<_> = account_keypairs
let src_keypairs: Vec<_> = account_keypairs
.drain(0..accounts_in_groups)
.map(|keypair| keypair)
.collect();
let src_pubkeys: Vec<Pubkey> = src_keypairs
.iter()
.map(|keypair| keypair.pubkey())
.collect();
let profit_pubkeys: Vec<_> = account_keypairs
let profit_keypairs: Vec<_> = account_keypairs
.drain(0..accounts_in_groups)
.map(|keypair| keypair)
.collect();
let profit_pubkeys: Vec<Pubkey> = profit_keypairs
.iter()
.map(|keypair| keypair.pubkey())
.collect();
info!("Create {:?} source token accounts", src_pubkeys.len());
create_token_accounts(client, &trader_signers, &src_pubkeys);
create_token_accounts(client, &trader_signers, &src_keypairs);
info!("Create {:?} profit token accounts", profit_pubkeys.len());
create_token_accounts(client, &swapper_signers, &profit_pubkeys);
create_token_accounts(client, &swapper_signers, &profit_keypairs);
// Collect the max transaction rate and total tx count seen (single node only)
let sample_stats = Arc::new(RwLock::new(Vec::new()));
@ -564,7 +573,7 @@ fn trader<T>(
trade_account: trade.pubkey(),
order_info,
});
trades.push((signer, trade.pubkey(), side, src));
trades.push((signer, trade, side, src));
}
account_group = (account_group + 1) % account_groups as usize;
@ -575,16 +584,28 @@ fn trader<T>(
trades.chunks(chunk_size).for_each(|chunk| {
let trades_txs: Vec<_> = chunk
.par_iter()
.map(|(signer, trade, side, src)| {
let s: &Keypair = &signer;
let owner = &signer.pubkey();
.map(|(owner, trade, side, src)| {
let owner_pubkey = &owner.pubkey();
let trade_pubkey = &trade.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
Transaction::new_signed_instructions(
&[s],
&[owner.as_ref(), trade],
vec![
system_instruction::create_account(owner, trade, 1, space, &id()),
system_instruction::create_account(
owner_pubkey,
trade_pubkey,
1,
space,
&id(),
),
exchange_instruction::trade_request(
owner, trade, *side, pair, tokens, price, src,
owner_pubkey,
trade_pubkey,
*side,
pair,
tokens,
price,
src,
),
],
blockhash,
@ -803,21 +824,27 @@ pub fn fund_keys(client: &dyn Client, source: &Keypair, dests: &[Arc<Keypair>],
}
}
pub fn create_token_accounts(client: &dyn Client, signers: &[Arc<Keypair>], accounts: &[Pubkey]) {
let mut notfunded: Vec<(&Arc<Keypair>, &Pubkey)> = signers.iter().zip(accounts).collect();
pub fn create_token_accounts(client: &dyn Client, signers: &[Arc<Keypair>], accounts: &[Keypair]) {
let mut notfunded: Vec<(&Arc<Keypair>, &Keypair)> = signers.iter().zip(accounts).collect();
while !notfunded.is_empty() {
notfunded.chunks(FUND_CHUNK_LEN).for_each(|chunk| {
let mut to_create_txs: Vec<_> = chunk
.par_iter()
.map(|(signer, new)| {
let owner_pubkey = &signer.pubkey();
.map(|(from_keypair, new_keypair)| {
let owner_pubkey = &from_keypair.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix =
system_instruction::create_account(owner_pubkey, new, 1, space, &id());
let request_ix = exchange_instruction::account_request(owner_pubkey, new);
let create_ix = system_instruction::create_account(
owner_pubkey,
&new_keypair.pubkey(),
1,
space,
&id(),
);
let request_ix =
exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
(
signer,
(from_keypair, new_keypair),
Transaction::new_unsigned_instructions(vec![create_ix, request_ix]),
)
})
@ -838,9 +865,10 @@ pub fn create_token_accounts(client: &dyn Client, signers: &[Arc<Keypair>], acco
let (blockhash, _fee_calculator) = client
.get_recent_blockhash_with_commitment(CommitmentConfig::recent())
.expect("Failed to get blockhash");
to_create_txs.par_iter_mut().for_each(|(k, tx)| {
let kp: &Keypair = k;
tx.sign(&[kp], blockhash);
to_create_txs
.par_iter_mut()
.for_each(|((from_keypair, to_keypair), tx)| {
tx.sign(&[from_keypair.as_ref(), to_keypair], blockhash);
});
to_create_txs.iter().for_each(|(_, tx)| {
client.async_send_transaction(tx.clone()).expect("transfer");
@ -878,10 +906,10 @@ pub fn create_token_accounts(client: &dyn Client, signers: &[Arc<Keypair>], acco
}
});
let mut new_notfunded: Vec<(&Arc<Keypair>, &Pubkey)> = vec![];
let mut new_notfunded: Vec<(&Arc<Keypair>, &Keypair)> = vec![];
for f in &notfunded {
if client
.get_balance_with_commitment(&f.1, CommitmentConfig::recent())
.get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::recent())
.unwrap_or(0)
== 0
{

20
bench-tps/src/bench.rs
View File

@ -795,13 +795,10 @@ fn fund_move_keys<T: Client>(
info!("creating the libra funding account..");
let libra_funding_key = Keypair::new();
let tx = librapay_transaction::create_account(
funding_key,
&libra_funding_key.pubkey(),
1,
blockhash,
);
client.send_message(&[funding_key], tx.message).unwrap();
let tx = librapay_transaction::create_account(funding_key, &libra_funding_key, 1, blockhash);
client
.send_message(&[funding_key, &libra_funding_key], tx.message)
.unwrap();
info!("minting to funding keypair");
let tx = librapay_transaction::mint_tokens(
@ -829,8 +826,8 @@ fn fund_move_keys<T: Client>(
break;
}
let pubkeys: Vec<_> = keys.iter().map(|k| k.pubkey()).collect();
let tx = librapay_transaction::create_accounts(funding_key, &pubkeys, 1, blockhash);
let keypairs: Vec<_> = keys.iter().map(|k| k).collect();
let tx = librapay_transaction::create_accounts(funding_key, &keypairs, 1, blockhash);
let ser_size = bincode::serialized_size(&tx).unwrap();
@ -877,10 +874,9 @@ fn fund_move_keys<T: Client>(
let libra_funding_keys: Vec<_> = (0..NUM_FUNDING_KEYS).map(|_| Keypair::new()).collect();
for (i, key) in libra_funding_keys.iter().enumerate() {
let tx =
librapay_transaction::create_account(&funding_keys[i], &key.pubkey(), 1, blockhash);
let tx = librapay_transaction::create_account(&funding_keys[i], &key, 1, blockhash);
client
.send_message(&[&funding_keys[i]], tx.message)
.send_message(&[&funding_keys[i], &key], tx.message)
.unwrap();
let tx = librapay_transaction::transfer(

23
cli/src/cli.rs
View File

@ -622,7 +622,7 @@ fn process_deploy(
let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(program_data.len())?;
let mut create_account_tx = system_transaction::create_account(
&config.keypair,
&program_id.pubkey(),
&program_id,
blockhash,
minimum_balance,
program_data.len() as u64,
@ -656,8 +656,7 @@ fn process_deploy(
check_account_for_multiple_fees(rpc_client, config, &fee_calculator, &messages)?;
trace!("Creating program account");
let result =
rpc_client.send_and_confirm_transaction(&mut create_account_tx, &[&config.keypair]);
let result = rpc_client.send_and_confirm_transaction(&mut create_account_tx, &signers);
log_instruction_custom_error::<SystemError>(result)
.map_err(|_| CliError::DynamicProgramError("Program allocate space failed".to_string()))?;
@ -723,9 +722,14 @@ fn process_pay(
cancelable,
lamports,
);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], ixs, blockhash);
let mut tx = Transaction::new_signed_instructions(
&[&config.keypair, &contract_state],
ixs,
blockhash,
);
check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
let result =
rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
let signature_str = log_instruction_custom_error::<BudgetError>(result)?;
Ok(json!({
@ -756,8 +760,13 @@ fn process_pay(
cancelable,
lamports,
);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], ixs, blockhash);
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
let mut tx = Transaction::new_signed_instructions(
&[&config.keypair, &contract_state],
ixs,
blockhash,
);
let result =
rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, &contract_state]);
check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
let signature_str = log_instruction_custom_error::<BudgetError>(result)?;

5
cli/src/stake.rs
View File

@ -424,11 +424,12 @@ pub fn process_create_stake_account(
let mut tx = Transaction::new_signed_with_payer(
ixs,
Some(&config.keypair.pubkey()),
&[&config.keypair],
&[&config.keypair, stake_account],
recent_blockhash,
);
check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
let result =
rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, stake_account]);
log_instruction_custom_error::<SystemError>(result)
}

9
cli/src/storage.rs
View File

@ -174,9 +174,14 @@ pub fn process_create_storage_account(
1,
account_type,
);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], ixs, recent_blockhash);
let mut tx = Transaction::new_signed_instructions(
&[&config.keypair, &storage_account],
ixs,
recent_blockhash,
);
check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
let result =
rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, &storage_account]);
log_instruction_custom_error::<SystemError>(result)
}

8
cli/src/vote.rs
View File

@ -267,9 +267,13 @@ pub fn process_create_vote_account(
lamports,
);
let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], ixs, recent_blockhash);
let mut tx = Transaction::new_signed_instructions(
&[&config.keypair, vote_account],
ixs,
recent_blockhash,
);
check_account_for_fee(rpc_client, config, &fee_calculator, &tx.message)?;
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair, vote_account]);
log_instruction_custom_error::<SystemError>(result)
}

6
core/src/rpc_pubsub.rs
View File

@ -402,7 +402,11 @@ mod tests {
None,
51,
);
let tx = Transaction::new_signed_instructions(&[&contract_funds], ixs, blockhash);
let tx = Transaction::new_signed_instructions(
&[&contract_funds, &contract_state],
ixs,
blockhash,
);
process_transaction_and_notify(&bank_forks, &tx, &rpc.subscriptions).unwrap();
sleep(Duration::from_millis(200));

4
core/src/rpc_subscriptions.rs
View File

@ -316,7 +316,7 @@ mod tests {
let alice = Keypair::new();
let tx = system_transaction::create_account(
&mint_keypair,
&alice.pubkey(),
&alice,
blockhash,
1,
16,
@ -371,7 +371,7 @@ mod tests {
let alice = Keypair::new();
let tx = system_transaction::create_account(
&mint_keypair,
&alice.pubkey(),
&alice,
blockhash,
1,
16,

2
core/tests/storage_stage.rs
View File

@ -86,7 +86,7 @@ mod tests {
StorageAccountType::Archiver,
);
let account_tx = Transaction::new_signed_instructions(
&[&mint_keypair],
&[&mint_keypair, &archiver_keypair],
account_ix,
bank.last_blockhash(),
);

13
ledger/src/blocktree_processor.rs
View File

@ -534,6 +534,7 @@ pub mod tests {
};
use matches::assert_matches;
use rand::{thread_rng, Rng};
use solana_sdk::account::Account;
use solana_sdk::{
epoch_schedule::EpochSchedule,
hash::Hash,
@ -1576,6 +1577,10 @@ pub mod tests {
}
let mut hash = bank.last_blockhash();
let present_account_key = Keypair::new();
let present_account = Account::new(1, 10, &Pubkey::default());
bank.store_account(&present_account_key.pubkey(), &present_account);
let entries: Vec<_> = (0..NUM_TRANSFERS)
.step_by(NUM_TRANSFERS_PER_ENTRY)
.map(|i| {
@ -1592,7 +1597,7 @@ pub mod tests {
transactions.push(system_transaction::create_account(
&mint_keypair,
&solana_sdk::sysvar::clock::id(), // puts a TX error in results
&present_account_key, // puts a TX error in results
bank.last_blockhash(),
1,
0,
@ -1926,6 +1931,10 @@ pub mod tests {
.expect("funding failed");
}
let present_account_key = Keypair::new();
let present_account = Account::new(1, 10, &Pubkey::default());
bank.store_account(&present_account_key.pubkey(), &present_account);
let mut i = 0;
let mut hash = bank.last_blockhash();
let mut root: Option<Arc<Bank>> = None;
@ -1947,7 +1956,7 @@ pub mod tests {
transactions.push(system_transaction::create_account(
&mint_keypair,
&solana_sdk::sysvar::clock::id(), // puts a TX error in results
&present_account_key, // puts a TX error in results
bank.last_blockhash(),
100,
100,

6
ledger/src/entry.rs
View File

@ -402,8 +402,10 @@ mod tests {
fn create_sample_payment(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ixs = budget_instruction::payment(&pubkey, &pubkey, 1);
Transaction::new_signed_instructions(&[keypair], ixs, hash)
let budget_contract = Keypair::new();
let budget_pubkey = budget_contract.pubkey();
let ixs = budget_instruction::payment(&pubkey, &pubkey, &budget_pubkey, 1);
Transaction::new_signed_instructions(&[keypair, &budget_contract], ixs, hash)
}
fn create_sample_timestamp(keypair: &Keypair, hash: Hash) -> Transaction {

5
ledger/src/leader_schedule_cache.rs
View File

@ -247,6 +247,7 @@ mod tests {
EpochSchedule, DEFAULT_LEADER_SCHEDULE_SLOT_OFFSET, DEFAULT_SLOTS_PER_EPOCH,
MINIMUM_SLOTS_PER_EPOCH,
};
use solana_sdk::signature::{Keypair, KeypairUtil};
use std::{sync::mpsc::channel, sync::Arc, thread::Builder};
#[test]
@ -496,11 +497,11 @@ mod tests {
// Create new vote account
let node_pubkey = Pubkey::new_rand();
let vote_pubkey = Pubkey::new_rand();
let vote_account = Keypair::new();
setup_vote_and_stake_accounts(
&bank,
&mint_keypair,
&vote_pubkey,
&vote_account,
&node_pubkey,
BOOTSTRAP_LEADER_LAMPORTS,
);

19
ledger/src/staking_utils.rs
View File

@ -88,7 +88,7 @@ where
// Find if any slot has achieved sufficient votes for supermajority lockout
let mut total = 0;
for (stake, slot) in stakes_and_lockouts {
total += stake;
total += *stake;
if total > supermajority_stake {
return Some(slot);
}
@ -125,10 +125,11 @@ pub(crate) mod tests {
pub(crate) fn setup_vote_and_stake_accounts(
bank: &Bank,
from_account: &Keypair,
vote_pubkey: &Pubkey,
vote_account: &Keypair,
node_pubkey: &Pubkey,
amount: u64,
) {
let vote_pubkey = vote_account.pubkey();
fn process_instructions<T: KeypairUtil>(
bank: &Bank,
keypairs: &[&T],
@ -145,14 +146,14 @@ pub(crate) mod tests {
process_instructions(
bank,
&[from_account],
&[from_account, vote_account],
vote_instruction::create_account(
&from_account.pubkey(),
vote_pubkey,
&vote_pubkey,
&VoteInit {
node_pubkey: *node_pubkey,
authorized_voter: *vote_pubkey,
authorized_withdrawer: *vote_pubkey,
authorized_voter: vote_pubkey,
authorized_withdrawer: vote_pubkey,
commission: 0,
},
amount,
@ -168,7 +169,7 @@ pub(crate) mod tests {
stake_instruction::create_stake_account_and_delegate_stake(
&from_account.pubkey(),
&stake_account_pubkey,
vote_pubkey,
&vote_pubkey,
&Authorized::auto(&stake_account_pubkey),
amount,
),
@ -193,7 +194,7 @@ pub(crate) mod tests {
} = create_genesis_block(10_000);
let bank = Bank::new(&genesis_block);
let vote_pubkey = Pubkey::new_rand();
let vote_account = Keypair::new();
// Give the validator some stake but don't setup a staking account
// Validator has no lamports staked, so they get filtered out. Only the bootstrap leader
@ -206,7 +207,7 @@ pub(crate) mod tests {
setup_vote_and_stake_accounts(
&bank,
&mint_keypair,
&vote_pubkey,
&vote_account,
&mint_keypair.pubkey(),
stake,
);

5
local_cluster/src/local_cluster.rs
View File

@ -472,7 +472,7 @@ impl LocalCluster {
// 1) Create vote account
let mut transaction = Transaction::new_signed_instructions(
&[from_account.as_ref()],
&[from_account.as_ref(), vote_account],
vote_instruction::create_account(
&from_account.pubkey(),
&vote_account_pubkey,
@ -596,7 +596,8 @@ impl LocalCluster {
),
Some(&from_keypair.pubkey()),
);
let signer_keys = vec![from_keypair.as_ref()];
let signer_keys = vec![from_keypair.as_ref(), &storage_keypair];
let blockhash = client
.get_recent_blockhash_with_commitment(CommitmentConfig::recent())
.unwrap()

6
programs/budget_api/src/budget_instruction.rs
View File

@ -82,8 +82,7 @@ pub fn create_account(
}
/// Create a new payment script.
pub fn payment(from: &Pubkey, to: &Pubkey, lamports: u64) -> Vec<Instruction> {
let contract = Pubkey::new_rand();
pub fn payment(from: &Pubkey, to: &Pubkey, contract: &Pubkey, lamports: u64) -> Vec<Instruction> {
let expr = BudgetExpr::new_payment(lamports, to);
create_account(from, &contract, lamports, expr)
}
@ -181,7 +180,8 @@ mod tests {
fn test_budget_instruction_verify() {
let alice_pubkey = Pubkey::new_rand();
let bob_pubkey = Pubkey::new_rand();
payment(&alice_pubkey, &bob_pubkey, 1); // No panic! indicates success.
let budget_pubkey = Pubkey::new_rand();
payment(&alice_pubkey, &bob_pubkey, &budget_pubkey, 1); // No panic! indicates success.
}
#[test]

33
programs/budget_api/src/budget_processor.rs
View File

@ -210,10 +210,13 @@ mod tests {
let bank_client = BankClient::new(bank);
let alice_pubkey = alice_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let instructions = budget_instruction::payment(&alice_pubkey, &bob_pubkey, 100);
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let instructions =
budget_instruction::payment(&alice_pubkey, &bob_pubkey, &budget_pubkey, 100);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
assert_eq!(bank_client.get_balance(&bob_pubkey).unwrap(), 100);
}
@ -225,7 +228,8 @@ mod tests {
let alice_pubkey = alice_keypair.pubkey();
// Initialize BudgetState
let budget_pubkey = Pubkey::new_rand();
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let witness = Pubkey::new_rand();
let instructions = budget_instruction::when_signed(
@ -238,7 +242,7 @@ mod tests {
);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
// Attack! Part 1: Sign a witness transaction with a random key.
@ -273,7 +277,8 @@ mod tests {
let alice_pubkey = alice_keypair.pubkey();
// Initialize BudgetState
let budget_pubkey = Pubkey::new_rand();
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let dt = Utc::now();
let instructions = budget_instruction::on_date(
@ -287,7 +292,7 @@ mod tests {
);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
// Attack! Part 1: Sign a timestamp transaction with a random key.
@ -320,10 +325,12 @@ mod tests {
let (bank, alice_keypair) = create_bank(2);
let bank_client = BankClient::new(bank);
let alice_pubkey = alice_keypair.pubkey();
let budget_pubkey = Pubkey::new_rand();
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let mallory_pubkey = Pubkey::new_rand();
let dt = Utc::now();
let instructions = budget_instruction::on_date(
&alice_pubkey,
&bob_pubkey,
@ -335,7 +342,7 @@ mod tests {
);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
assert_eq!(bank_client.get_balance(&alice_pubkey).unwrap(), 1);
assert_eq!(bank_client.get_balance(&budget_pubkey).unwrap(), 1);
@ -389,7 +396,8 @@ mod tests {
let (bank, alice_keypair) = create_bank(3);
let bank_client = BankClient::new(bank);
let alice_pubkey = alice_keypair.pubkey();
let budget_pubkey = Pubkey::new_rand();
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let dt = Utc::now();
@ -404,7 +412,7 @@ mod tests {
);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
assert_eq!(bank_client.get_balance(&alice_pubkey).unwrap(), 2);
assert_eq!(bank_client.get_balance(&budget_pubkey).unwrap(), 1);
@ -461,7 +469,8 @@ mod tests {
let alice_pubkey = alice_keypair.pubkey();
let game_hash = hash(&[1, 2, 3]);
let budget_pubkey = Pubkey::new_rand();
let budget_keypair = Keypair::new();
let budget_pubkey = budget_keypair.pubkey();
let bob_keypair = Keypair::new();
let bob_pubkey = bob_keypair.pubkey();
@ -481,7 +490,7 @@ mod tests {
);
let message = Message::new(instructions);
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &budget_keypair], message)
.unwrap();
assert_eq!(bank_client.get_balance(&alice_pubkey).unwrap(), 0);
assert_eq!(bank_client.get_balance(&budget_pubkey).unwrap(), 41);

5
programs/config_tests/tests/config_processor.rs
View File

@ -371,10 +371,11 @@ fn test_config_updates_requiring_config() {
fn test_config_initialize_no_panic() {
let (bank, alice_keypair) = create_bank(3);
let bank_client = BankClient::new(bank);
let config_account = Keypair::new();
let mut instructions = config_instruction::create_account::<MyConfig>(
&alice_keypair.pubkey(),
&Pubkey::new_rand(),
&config_account.pubkey(),
1,
vec![],
);
@ -383,7 +384,7 @@ fn test_config_initialize_no_panic() {
let message = Message::new(instructions);
assert_eq!(
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &config_account], message)
.unwrap_err()
.unwrap(),
TransactionError::InstructionError(1, InstructionError::NotEnoughAccountKeys)

11
programs/exchange_api/src/exchange_processor.rs
View File

@ -458,6 +458,7 @@ mod test {
use solana_runtime::bank_client::BankClient;
use solana_sdk::client::SyncClient;
use solana_sdk::genesis_block::create_genesis_block;
use solana_sdk::message::Message;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction;
use std::mem;
@ -557,18 +558,20 @@ mod test {
}
fn create_account(client: &BankClient, owner: &Keypair) -> Pubkey {
let new = Pubkey::new_rand();
let new = Keypair::new();
let instruction = system_instruction::create_account(
&owner.pubkey(),
&new,
&new.pubkey(),
1,
mem::size_of::<ExchangeState>() as u64,
&id(),
);
client
.send_instruction(&owner, instruction)
.send_message(&[owner, &new], Message::new(vec![instruction]))
.expect(&format!("{}:{}", line!(), file!()));
new
new.pubkey()
}
fn create_token_account(client: &BankClient, owner: &Keypair) -> Pubkey {

8
programs/librapay_api/src/lib.rs
View File

@ -36,7 +36,13 @@ pub fn create_genesis<T: Client>(from_key: &Keypair, client: &T, amount: u64) ->
as u64,
&solana_sdk::move_loader::id(),
);
client.send_instruction(&from_key, instruction).unwrap();
client
.send_message(
&[&from_key, &libra_genesis_key],
Message::new(vec![instruction]),
)
.unwrap();
let instruction = librapay_instruction::genesis(&libra_genesis_key.pubkey(), amount);
let message = Message::new_with_payer(vec![instruction], Some(&from_key.pubkey()));

22
programs/librapay_api/src/librapay_transaction.rs
View File

@ -63,32 +63,35 @@ pub fn transfer(
pub fn create_accounts(
from: &Keypair,
tos: &[Pubkey],
to: &[&Keypair],
lamports: u64,
recent_blockhash: Hash,
) -> Transaction {
let instructions = tos
let instructions = to
.iter()
.map(|to| {
system_instruction::create_account(
&from.pubkey(),
to,
&to.pubkey(),
lamports,
400,
&solana_sdk::move_loader::id(),
)
})
.collect();
Transaction::new_signed_instructions(&[from], instructions, recent_blockhash)
let mut from_signers = vec![from];
from_signers.extend_from_slice(to);
Transaction::new_signed_instructions(&from_signers, instructions, recent_blockhash)
}
pub fn create_account(
from: &Keypair,
to: &Pubkey,
to: &Keypair,
lamports: u64,
recent_blockhash: Hash,
) -> Transaction {
create_accounts(from, &[*to], lamports, recent_blockhash)
create_accounts(from, &[to], lamports, recent_blockhash)
}
#[derive(Debug)]
@ -172,12 +175,7 @@ mod tests {
let from = Keypair::new();
let to = Keypair::new();
let tx = create_accounts(
&mint_keypair,
&[from.pubkey(), to.pubkey()],
1,
bank.last_blockhash(),
);
let tx = create_accounts(&mint_keypair, &[&from, &to], 1, bank.last_blockhash());
bank.process_transaction(&tx).unwrap();
info!(

2
programs/stake_tests/tests/stake_instruction.rs
View File

@ -92,7 +92,7 @@ fn test_stake_account_delegate() {
10,
));
bank_client
.send_message(&[&mint_keypair], message)
.send_message(&[&mint_keypair, &vote_keypair], message)
.expect("failed to create vote account");
let authorized = stake_state::Authorized::auto(&staker_pubkey);

35
programs/storage_program/tests/storage_processor.rs
View File

@ -56,8 +56,10 @@ fn test_instruction(
#[test]
fn test_account_owner() {
let account_owner = Pubkey::new_rand();
let validator_storage_pubkey = Pubkey::new_rand();
let archiver_storage_pubkey = Pubkey::new_rand();
let validator_storage_keypair = Keypair::new();
let validator_storage_pubkey = validator_storage_keypair.pubkey();
let archiver_storage_keypair = Keypair::new();
let archiver_storage_pubkey = archiver_storage_keypair.pubkey();
let GenesisBlockInfo {
genesis_block,
@ -78,7 +80,7 @@ fn test_account_owner() {
StorageAccountType::Validator,
));
bank_client
.send_message(&[&mint_keypair], message)
.send_message(&[&mint_keypair, &validator_storage_keypair], message)
.expect("failed to create account");
let account = bank
.get_account(&validator_storage_pubkey)
@ -98,7 +100,7 @@ fn test_account_owner() {
StorageAccountType::Archiver,
));
bank_client
.send_message(&[&mint_keypair], message)
.send_message(&[&mint_keypair, &archiver_storage_keypair], message)
.expect("failed to create account");
let account = bank
.get_account(&archiver_storage_pubkey)
@ -290,8 +292,8 @@ fn test_validate_mining() {
&owner_pubkey,
&bank_client,
&mint_keypair,
&[&validator_storage_id],
&[&archiver_1_storage_id, &archiver_2_storage_id],
&[&validator_storage_keypair],
&[&archiver_1_storage_keypair, &archiver_2_storage_keypair],
10,
);
@ -465,19 +467,21 @@ fn init_storage_accounts(
owner: &Pubkey,
client: &BankClient,
mint: &Keypair,
validator_accounts_to_create: &[&Pubkey],
archiver_accounts_to_create: &[&Pubkey],
validator_accounts_to_create: &[&Keypair],
archiver_accounts_to_create: &[&Keypair],
lamports: u64,
) {
let mut signers = vec![mint];
let mut ixs: Vec<_> = vec![system_instruction::transfer(&mint.pubkey(), owner, 1)];
ixs.append(
&mut validator_accounts_to_create
.into_iter()
.flat_map(|account| {
signers.push(&account);
storage_instruction::create_storage_account(
&mint.pubkey(),
owner,
account,
&account.pubkey(),
lamports,
StorageAccountType::Validator,
)
@ -485,16 +489,17 @@ fn init_storage_accounts(
.collect(),
);
archiver_accounts_to_create.into_iter().for_each(|account| {
signers.push(&account);
ixs.append(&mut storage_instruction::create_storage_account(
&mint.pubkey(),
owner,
account,
&account.pubkey(),
lamports,
StorageAccountType::Archiver,
))
});
let message = Message::new(ixs);
client.send_message(&[mint], message).unwrap();
client.send_message(&signers, message).unwrap();
}
fn get_storage_segment<C: SyncClient>(client: &C, account: &Pubkey) -> u64 {
@ -594,7 +599,9 @@ fn test_bank_storage() {
11,
StorageAccountType::Archiver,
));
bank_client.send_message(&[&mint_keypair], message).unwrap();
bank_client
.send_message(&[&mint_keypair, &archiver_keypair], message)
.unwrap();
let message = Message::new(storage_instruction::create_storage_account(
&mint_pubkey,
@ -603,7 +610,9 @@ fn test_bank_storage() {
1,
StorageAccountType::Validator,
));
bank_client.send_message(&[&mint_keypair], message).unwrap();
bank_client
.send_message(&[&mint_keypair, &validator_keypair], message)
.unwrap();
let message = Message::new_with_payer(
vec![storage_instruction::advertise_recent_blockhash(

37
programs/vest_api/src/vest_processor.rs
View File

@ -192,7 +192,7 @@ mod tests {
fn create_vest_account(
bank_client: &BankClient,
contract_pubkey: &Pubkey,
contract_keypair: &Keypair,
payer_keypair: &Keypair,
terminator_pubkey: &Pubkey,
payee_pubkey: &Pubkey,
@ -203,14 +203,14 @@ mod tests {
let instructions = vest_instruction::create_account(
&payer_keypair.pubkey(),
&terminator_pubkey,
&contract_pubkey,
&contract_keypair.pubkey(),
&payee_pubkey,
start_date,
&date_pubkey,
lamports,
);
let message = Message::new(instructions);
bank_client.send_message(&[&payer_keypair], message)
bank_client.send_message(&[&payer_keypair, &contract_keypair], message)
}
fn send_set_terminator(
@ -327,10 +327,12 @@ mod tests {
fn test_initialize_no_panic() {
let (bank_client, alice_keypair) = create_bank_client(3);
let contract_keypair = Keypair::new();
let mut instructions = vest_instruction::create_account(
&alice_keypair.pubkey(),
&Pubkey::new_rand(),
&Pubkey::new_rand(),
&contract_keypair.pubkey(),
&Pubkey::new_rand(),
Utc::now().date(),
&Pubkey::new_rand(),
@ -341,7 +343,7 @@ mod tests {
let message = Message::new(instructions);
assert_eq!(
bank_client
.send_message(&[&alice_keypair], message)
.send_message(&[&alice_keypair, &contract_keypair], message)
.unwrap_err()
.unwrap(),
TransactionError::InstructionError(1, InstructionError::NotEnoughAccountKeys)
@ -352,14 +354,15 @@ mod tests {
let (bank_client, alice_keypair) = create_bank_client(39);
let alice_pubkey = alice_keypair.pubkey();
let date_pubkey = Pubkey::new_rand();
let contract_pubkey = Pubkey::new_rand();
let contract_keypair = Keypair::new();
let contract_pubkey = contract_keypair.pubkey();
let bob_keypair = Keypair::new();
let bob_pubkey = bob_keypair.pubkey();
let start_date = Utc.ymd(2018, 1, 1);
create_vest_account(
&bank_client,
&contract_pubkey,
&contract_keypair,
&alice_keypair,
&alice_pubkey,
&bob_pubkey,
@ -422,14 +425,15 @@ mod tests {
let (bank_client, alice_keypair) = create_bank_client(38);
let alice_pubkey = alice_keypair.pubkey();
let date_pubkey = Pubkey::new_rand();
let contract_pubkey = Pubkey::new_rand();
let contract_keypair = Keypair::new();
let contract_pubkey = contract_keypair.pubkey();
let bob_keypair = Keypair::new();
let bob_pubkey = bob_keypair.pubkey();
let start_date = Utc.ymd(2018, 1, 1);
create_vest_account(
&bank_client,
&contract_pubkey,
&contract_keypair,
&alice_keypair,
&alice_pubkey,
&bob_pubkey,
@ -481,13 +485,14 @@ mod tests {
let current_date = Utc.ymd(2019, 1, 1);
create_date_account(&bank_client, &date_keypair, &alice_keypair, current_date).unwrap();
let contract_pubkey = Pubkey::new_rand();
let contract_keypair = Keypair::new();
let contract_pubkey = contract_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let start_date = Utc.ymd(2018, 1, 1);
create_vest_account(
&bank_client,
&contract_pubkey,
&contract_keypair,
&alice_keypair,
&alice_pubkey,
&bob_pubkey,
@ -542,7 +547,8 @@ mod tests {
fn test_terminate_and_refund() {
let (bank_client, alice_keypair) = create_bank_client(3);
let alice_pubkey = alice_keypair.pubkey();
let contract_pubkey = Pubkey::new_rand();
let contract_keypair = Keypair::new();
let contract_pubkey = contract_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let start_date = Utc::now().date();
@ -554,7 +560,7 @@ mod tests {
create_vest_account(
&bank_client,
&contract_pubkey,
&contract_keypair,
&alice_keypair,
&alice_pubkey,
&bob_pubkey,
@ -585,7 +591,8 @@ mod tests {
fn test_terminate_and_send_funds() {
let (bank_client, alice_keypair) = create_bank_client(3);
let alice_pubkey = alice_keypair.pubkey();
let contract_pubkey = Pubkey::new_rand();
let contract_keypair = Keypair::new();
let contract_pubkey = contract_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let start_date = Utc::now().date();
@ -597,7 +604,7 @@ mod tests {
create_vest_account(
&bank_client,
&contract_pubkey,
&contract_keypair,
&alice_keypair,
&alice_pubkey,
&bob_pubkey,

6
runtime/src/bank.rs
View File

@ -3066,7 +3066,7 @@ mod tests {
);
let transaction = Transaction::new_signed_instructions(
&[&mint_keypair],
&[&mint_keypair, &vote_keypair],
instructions,
bank.last_blockhash(),
);
@ -3287,7 +3287,7 @@ mod tests {
);
let transaction = Transaction::new_signed_instructions(
&[&mint_keypair],
&[&mint_keypair, &mock_account],
instructions,
bank.last_blockhash(),
);
@ -3328,7 +3328,7 @@ mod tests {
);
let transaction = Transaction::new_signed_instructions(
&[&mint_keypair],
&[&mint_keypair, &mock_account],
instructions,
bank.last_blockhash(),
);

5
runtime/src/loader_utils.rs
View File

@ -24,7 +24,10 @@ pub fn load_program<T: Client>(
loader_pubkey,
);
bank_client
.send_instruction(&from_keypair, instruction)
.send_message(
&[from_keypair, &program_keypair],
Message::new(vec![instruction]),
)
.unwrap();
let chunk_size = 256; // Size of chunk just needs to fit into tx

8
runtime/src/storage_utils.rs
View File

@ -117,7 +117,9 @@ pub(crate) mod tests {
11,
StorageAccountType::Archiver,
));
bank_client.send_message(&[&mint_keypair], message).unwrap();
bank_client
.send_message(&[&mint_keypair, &archiver_keypair], message)
.unwrap();
let message = Message::new(storage_instruction::create_storage_account(
&mint_pubkey,
@ -126,7 +128,9 @@ pub(crate) mod tests {
11,
StorageAccountType::Validator,
));
bank_client.send_message(&[&mint_keypair], message).unwrap();
bank_client
.send_message(&[&mint_keypair, &validator_keypair], message)
.unwrap();
assert_eq!(validator_accounts(bank.as_ref()).len(), 1);
assert_eq!(archiver_accounts(bank.as_ref()).len(), 1);

36
runtime/src/system_instruction_processor.rs
View File

@ -20,6 +20,11 @@ fn create_system_account(
return Err(InstructionError::MissingRequiredSignature);
}
if to.signer_key().is_none() {
debug!("CreateAccount: to must sign");
return Err(InstructionError::MissingRequiredSignature);
}
// if it looks like the to account is already in use, bail
if to.account.lamports != 0
|| !to.account.data.is_empty()
@ -157,7 +162,7 @@ mod tests {
assert_eq!(
create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&to, false, &mut to_account),
&mut KeyedAccount::new(&to, true, &mut to_account),
50,
2,
&new_program_owner,
@ -188,7 +193,7 @@ mod tests {
assert_eq!(
create_system_account(
&mut KeyedAccount::new(&from, false, &mut from_account), // no signer
&mut KeyedAccount::new(&to, false, &mut to_account),
&mut KeyedAccount::new(&to, true, &mut to_account),
0,
2,
&new_program_owner,
@ -219,7 +224,7 @@ mod tests {
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&to, false, &mut to_account),
&mut KeyedAccount::new(&to, true, &mut to_account),
150,
2,
&new_program_owner,
@ -244,7 +249,7 @@ mod tests {
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&owned_key, false, &mut owned_account),
&mut KeyedAccount::new(&owned_key, true, &mut owned_account),
50,
2,
&new_program_owner,
@ -259,7 +264,7 @@ mod tests {
let unchanged_account = owned_account.clone();
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&owned_key, false, &mut owned_account),
&mut KeyedAccount::new(&owned_key, true, &mut owned_account),
50,
2,
&new_program_owner,
@ -281,8 +286,21 @@ mod tests {
let mut owned_account = Account::new(0, 0, &Pubkey::default());
let unchanged_account = owned_account.clone();
// Haven't signed from account
let result = create_system_account(
&mut KeyedAccount::new(&from, false, &mut from_account),
&mut KeyedAccount::new(&owned_key, true, &mut owned_account),
50,
2,
&new_program_owner,
);
assert_eq!(result, Err(InstructionError::MissingRequiredSignature));
assert_eq!(from_account.lamports, 100);
assert_eq!(owned_account, unchanged_account);
// Haven't signed to account
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&owned_key, false, &mut owned_account),
50,
2,
@ -295,7 +313,7 @@ mod tests {
// support creation/assignment with zero lamports (ephemeral account)
let result = create_system_account(
&mut KeyedAccount::new(&from, false, &mut from_account),
&mut KeyedAccount::new(&owned_key, false, &mut owned_account),
&mut KeyedAccount::new(&owned_key, true, &mut owned_account),
0,
2,
&new_program_owner,
@ -317,7 +335,7 @@ mod tests {
// fail to create a sysvar::id() owned account
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&to, false, &mut to_account),
&mut KeyedAccount::new(&to, true, &mut to_account),
50,
2,
&sysvar::id(),
@ -330,7 +348,7 @@ mod tests {
// fail to create an account with a sysvar id
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&to, false, &mut to_account),
&mut KeyedAccount::new(&to, true, &mut to_account),
50,
2,
&system_program::id(),
@ -357,7 +375,7 @@ mod tests {
let result = create_system_account(
&mut KeyedAccount::new(&from, true, &mut from_account),
&mut KeyedAccount::new(&populated_key, false, &mut populated_account),
&mut KeyedAccount::new(&populated_key, true, &mut populated_account),
50,
2,
&new_program_owner,

2
sdk/src/system_instruction.rs
View File

@ -56,7 +56,7 @@ pub fn create_account(
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_pubkey, true),
AccountMeta::new(*to_pubkey, false),
AccountMeta::new(*to_pubkey, true),
];
Instruction::new(
system_program::id(),

11
sdk/src/system_transaction.rs
View File

@ -11,17 +11,22 @@ use crate::{
/// Create and sign new SystemInstruction::CreateAccount transaction
pub fn create_account(
from_keypair: &Keypair,
to: &Pubkey,
to_keypair: &Keypair,
recent_blockhash: Hash,
lamports: u64,
space: u64,
program_id: &Pubkey,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let to_pubkey = to_keypair.pubkey();
let create_instruction =
system_instruction::create_account(&from_pubkey, to, lamports, space, program_id);
system_instruction::create_account(&from_pubkey, &to_pubkey, lamports, space, program_id);
let instructions = vec![create_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
Transaction::new_signed_instructions(
&[from_keypair, to_keypair],
instructions,
recent_blockhash,
)
}
/// Create and sign new system_instruction::Assign transaction