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

Remove Instruction wrapper structs and name functions after enum fields

This commit is contained in:
Greg Fitzgerald 2019-04-03 09:45:57 -06:00 committed by Grimes
parent 867f6f107b
commit 35298e01a8
53 changed files with 835 additions and 922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -13,8 +13,8 @@ use solana_metrics::influxdb;
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_instruction;
use solana_sdk::system_transaction;
use solana_sdk::timing::timestamp;
use solana_sdk::timing::{duration_as_ms, duration_as_s};
use solana_sdk::transaction::Transaction;
@ -321,7 +321,7 @@ fn send_barrier_transaction(
*blockhash = barrier_client.get_recent_blockhash().unwrap();
let transaction =
SystemTransaction::new_user_account(&source_keypair, dest_id, 0, *blockhash, 0);
system_transaction::create_user_account(&source_keypair, dest_id, 0, *blockhash, 0);
let signature = barrier_client
.transfer_signed(&transaction)
.expect("Unable to send barrier transaction");
@ -399,7 +399,7 @@ fn generate_txs(
.par_iter()
.map(|(id, keypair)| {
(
SystemTransaction::new_user_account(id, &keypair.pubkey(), 1, blockhash, 0),
system_transaction::create_user_account(id, &keypair.pubkey(), 1, blockhash, 0),
timestamp(),
)
})
@ -551,9 +551,10 @@ fn fund_keys(client: &ThinClient, source: &Keypair, dests: &[Keypair], lamports:
.map(|(k, m)| {
(
k.clone(),
Transaction::new_unsigned_instructions(
SystemInstruction::new_transfer_many(&k.pubkey(), &m),
),
Transaction::new_unsigned_instructions(system_instruction::transfer_many(
&k.pubkey(),
&m,
)),
)
})
.collect();

10
client/src/rpc_client.rs
View File

@ -556,7 +556,7 @@ mod tests {
use serde_json::Number;
use solana_logger;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::sync::mpsc::channel;
use std::thread;
@ -662,7 +662,7 @@ mod tests {
let key = Keypair::new();
let to = Pubkey::new_rand();
let blockhash = Hash::default();
let tx = SystemTransaction::new_user_account(&key, &to, 50, blockhash, 0);
let tx = system_transaction::create_user_account(&key, &to, 50, blockhash, 0);
let signature = rpc_client.send_transaction(&tx);
assert_eq!(signature.unwrap(), SIGNATURE.to_string());
@ -713,7 +713,7 @@ mod tests {
let key = Keypair::new();
let to = Pubkey::new_rand();
let blockhash = Hash::default();
let mut tx = SystemTransaction::new_user_account(&key, &to, 50, blockhash, 0);
let mut tx = system_transaction::create_user_account(&key, &to, 50, blockhash, 0);
let result = rpc_client.send_and_confirm_transaction(&mut tx, &key);
result.unwrap();
@ -737,8 +737,8 @@ mod tests {
.into_vec()
.unwrap();
let blockhash = Hash::new(&vec);
let prev_tx = SystemTransaction::new_user_account(&key, &to, 50, blockhash, 0);
let mut tx = SystemTransaction::new_user_account(&key, &to, 50, blockhash, 0);
let prev_tx = system_transaction::create_user_account(&key, &to, 50, blockhash, 0);
let mut tx = system_transaction::create_user_account(&key, &to, 50, blockhash, 0);
rpc_client.resign_transaction(&mut tx, &key).unwrap();

10
core/benches/banking_stage.rs
View File

@ -18,7 +18,7 @@ use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::{DEFAULT_TICKS_PER_SLOT, MAX_RECENT_BLOCKHASHES};
use std::iter;
use std::sync::atomic::Ordering;
@ -56,7 +56,7 @@ fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
let (verified_sender, verified_receiver) = channel();
let bank = Arc::new(Bank::new(&genesis_block));
let dummy = SystemTransaction::new_transfer(
let dummy = system_transaction::transfer(
&mint_keypair,
&mint_keypair.pubkey(),
1,
@ -78,7 +78,7 @@ fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
.collect();
// fund all the accounts
transactions.iter().for_each(|tx| {
let fund = SystemTransaction::new_transfer(
let fund = system_transaction::transfer(
&mint_keypair,
&tx.message.account_keys[0],
mint_total / txes as u64,
@ -156,7 +156,7 @@ fn bench_banking_stage_multi_programs(bencher: &mut Bencher) {
let (verified_sender, verified_receiver) = channel();
let bank = Arc::new(Bank::new(&genesis_block));
let dummy = SystemTransaction::new_transfer(
let dummy = system_transaction::transfer(
&mint_keypair,
&mint_keypair.pubkey(),
1,
@ -194,7 +194,7 @@ fn bench_banking_stage_multi_programs(bencher: &mut Bencher) {
})
.collect();
transactions.iter().for_each(|tx| {
let fund = SystemTransaction::new_transfer(
let fund = system_transaction::transfer(
&mint_keypair,
&tx.message.account_keys[0],
mint_total / txes as u64,

4
core/benches/ledger.rs
View File

@ -5,7 +5,7 @@ extern crate test;
use solana::entry::{next_entries, reconstruct_entries_from_blobs, EntrySlice};
use solana_sdk::hash::{hash, Hash};
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use test::Bencher;
#[bench]
@ -13,7 +13,7 @@ fn bench_block_to_blobs_to_block(bencher: &mut Bencher) {
let zero = Hash::default();
let one = hash(&zero.as_ref());
let keypair = Keypair::new();
let tx0 = SystemTransaction::new_transfer(&keypair, &keypair.pubkey(), 1, one, 0);
let tx0 = system_transaction::transfer(&keypair, &keypair.pubkey(), 1, one, 0);
let transactions = vec![tx0; 10];
let entries = next_entries(&zero, 1, transactions);

23
core/src/banking_stage.rs
View File

@ -507,7 +507,7 @@ mod tests {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::instruction::InstructionError;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::sync::mpsc::channel;
use std::thread::sleep;
@ -593,7 +593,7 @@ mod tests {
// fund another account so we can send 2 good transactions in a single batch.
let keypair = Keypair::new();
let fund_tx = SystemTransaction::new_user_account(
let fund_tx = system_transaction::create_user_account(
&mint_keypair,
&keypair.pubkey(),
2,
@ -604,16 +604,17 @@ mod tests {
// good tx
let to = Pubkey::new_rand();
let tx = SystemTransaction::new_user_account(&mint_keypair, &to, 1, start_hash, 0);
let tx = system_transaction::create_user_account(&mint_keypair, &to, 1, start_hash, 0);
// good tx, but no verify
let to2 = Pubkey::new_rand();
let tx_no_ver = SystemTransaction::new_user_account(&keypair, &to2, 2, start_hash, 0);
let tx_no_ver =
system_transaction::create_user_account(&keypair, &to2, 2, start_hash, 0);
// bad tx, AccountNotFound
let keypair = Keypair::new();
let to3 = Pubkey::new_rand();
let tx_anf = SystemTransaction::new_user_account(&keypair, &to3, 1, start_hash, 0);
let tx_anf = system_transaction::create_user_account(&keypair, &to3, 1, start_hash, 0);
// send 'em over
let packets = to_packets(&[tx_no_ver, tx_anf, tx]);
@ -676,7 +677,7 @@ mod tests {
// Process a batch that includes a transaction that receives two lamports.
let alice = Keypair::new();
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&alice.pubkey(),
2,
@ -690,7 +691,7 @@ mod tests {
.unwrap();
// Process a second batch that spends one of those lamports.
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&alice,
&mint_keypair.pubkey(),
1,
@ -783,8 +784,8 @@ mod tests {
let pubkey = Pubkey::new_rand();
let transactions = vec![
SystemTransaction::new_transfer(&mint_keypair, &pubkey, 1, genesis_block.hash(), 0),
SystemTransaction::new_transfer(&mint_keypair, &pubkey, 1, genesis_block.hash(), 0),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash(), 0),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash(), 0),
];
let mut results = vec![Ok(()), Ok(())];
@ -820,7 +821,7 @@ mod tests {
let bank = Arc::new(Bank::new(&genesis_block));
let pubkey = Pubkey::new_rand();
let transactions = vec![SystemTransaction::new_transfer(
let transactions = vec![system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
@ -873,7 +874,7 @@ mod tests {
assert_eq!(done, true);
let transactions = vec![SystemTransaction::new_transfer(
let transactions = vec![system_transaction::transfer(
&mint_keypair,
&pubkey,
2,

6
core/src/blockstream.rs
View File

@ -172,7 +172,7 @@ mod test {
use serde_json::Value;
use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::collections::HashSet;
#[test]
@ -184,9 +184,9 @@ mod test {
let keypair0 = Keypair::new();
let keypair1 = Keypair::new();
let tx0 =
SystemTransaction::new_transfer(&keypair0, &keypair1.pubkey(), 1, Hash::default(), 0);
system_transaction::transfer(&keypair0, &keypair1.pubkey(), 1, Hash::default(), 0);
let tx1 =
SystemTransaction::new_transfer(&keypair1, &keypair0.pubkey(), 2, Hash::default(), 0);
system_transaction::transfer(&keypair1, &keypair0.pubkey(), 2, Hash::default(), 0);
let serialized_tx0 = serialize(&tx0).unwrap();
let serialized_tx1 = serialize(&tx1).unwrap();
let entry = Entry::new(&Hash::default(), 1, vec![tx0, tx1]);

11
core/src/blockstream_service.rs
View File

@ -115,7 +115,7 @@ mod test {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::sync::mpsc::channel;
#[test]
@ -141,8 +141,13 @@ mod test {
let keypair = Keypair::new();
let mut blockhash = entries[3].hash;
let tx =
SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 1, Hash::default(), 0);
let tx = system_transaction::create_user_account(
&keypair,
&keypair.pubkey(),
1,
Hash::default(),
0,
);
let entry = Entry::new(&mut blockhash, 1, vec![tx]);
blockhash = entry.hash;
entries.push(entry);

51
core/src/blocktree_processor.rs
View File

@ -233,7 +233,7 @@ mod tests {
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::TransactionError;
fn fill_blocktree_slot_with_ticks(
@ -421,7 +421,7 @@ mod tests {
let bank = Bank::new(&genesis_block);
let keypair = Keypair::new();
let slot_entries = create_ticks(genesis_block.ticks_per_slot - 1, genesis_block.hash());
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair.pubkey(),
1,
@ -453,7 +453,7 @@ mod tests {
for _ in 0..3 {
// Transfer one token from the mint to a random account
let keypair = Keypair::new();
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair.pubkey(),
1,
@ -467,8 +467,13 @@ mod tests {
// Add a second Transaction that will produce a
// InstructionError<0, ResultWithNegativeLamports> error when processed
let keypair2 = Keypair::new();
let tx =
SystemTransaction::new_user_account(&keypair, &keypair2.pubkey(), 42, blockhash, 0);
let tx = system_transaction::create_user_account(
&keypair,
&keypair2.pubkey(),
42,
blockhash,
0,
);
let entry = Entry::new(&last_entry_hash, 1, vec![tx]);
last_entry_hash = entry.hash;
entries.push(entry);
@ -545,7 +550,7 @@ mod tests {
let blockhash = bank.last_blockhash();
// ensure bank can process 2 entries that have a common account and no tick is registered
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair1.pubkey(),
2,
@ -553,7 +558,7 @@ mod tests {
0,
);
let entry_1 = next_entry(&blockhash, 1, vec![tx]);
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair2.pubkey(),
2,
@ -583,7 +588,7 @@ mod tests {
let entry_1_to_mint = next_entry(
&bank.last_blockhash(),
1,
vec![SystemTransaction::new_user_account(
vec![system_transaction::create_user_account(
&keypair1,
&mint_keypair.pubkey(),
1,
@ -596,14 +601,14 @@ mod tests {
&entry_1_to_mint.hash,
1,
vec![
SystemTransaction::new_user_account(
system_transaction::create_user_account(
&keypair2,
&keypair3.pubkey(),
2,
bank.last_blockhash(),
0,
), // should be fine
SystemTransaction::new_user_account(
system_transaction::create_user_account(
&keypair1,
&mint_keypair.pubkey(),
2,
@ -642,14 +647,14 @@ mod tests {
&bank.last_blockhash(),
1,
vec![
SystemTransaction::new_user_account(
system_transaction::create_user_account(
&keypair1,
&mint_keypair.pubkey(),
1,
bank.last_blockhash(),
0,
),
SystemTransaction::new_transfer(
system_transaction::transfer(
&keypair4,
&keypair4.pubkey(),
1,
@ -663,14 +668,14 @@ mod tests {
&entry_1_to_mint.hash,
1,
vec![
SystemTransaction::new_user_account(
system_transaction::create_user_account(
&keypair2,
&keypair3.pubkey(),
2,
bank.last_blockhash(),
0,
), // should be fine
SystemTransaction::new_user_account(
system_transaction::create_user_account(
&keypair1,
&mint_keypair.pubkey(),
2,
@ -715,7 +720,7 @@ mod tests {
let keypair4 = Keypair::new();
//load accounts
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair1.pubkey(),
1,
@ -723,7 +728,7 @@ mod tests {
0,
);
assert_eq!(bank.process_transaction(&tx), Ok(()));
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair2.pubkey(),
1,
@ -734,7 +739,7 @@ mod tests {
// ensure bank can process 2 entries that do not have a common account and no tick is registered
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&keypair1,
&keypair3.pubkey(),
1,
@ -742,7 +747,7 @@ mod tests {
0,
);
let entry_1 = next_entry(&blockhash, 1, vec![tx]);
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&keypair2,
&keypair4.pubkey(),
1,
@ -766,7 +771,7 @@ mod tests {
let keypair4 = Keypair::new();
//load accounts
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair1.pubkey(),
1,
@ -774,7 +779,7 @@ mod tests {
0,
);
assert_eq!(bank.process_transaction(&tx), Ok(()));
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&keypair2.pubkey(),
1,
@ -790,10 +795,10 @@ mod tests {
// ensure bank can process 2 entries that do not have a common account and tick is registered
let tx =
SystemTransaction::new_user_account(&keypair2, &keypair3.pubkey(), 1, blockhash, 0);
system_transaction::create_user_account(&keypair2, &keypair3.pubkey(), 1, blockhash, 0);
let entry_1 = next_entry(&blockhash, 1, vec![tx]);
let tick = next_entry(&entry_1.hash, 1, vec![]);
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&keypair1,
&keypair4.pubkey(),
1,
@ -809,7 +814,7 @@ mod tests {
assert_eq!(bank.get_balance(&keypair4.pubkey()), 1);
// ensure that an error is returned for an empty account (keypair2)
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&keypair2,
&keypair3.pubkey(),
1,

4
core/src/chacha.rs
View File

@ -97,7 +97,7 @@ mod tests {
use ring::signature::Ed25519KeyPair;
use solana_sdk::hash::{hash, Hash, Hasher};
use solana_sdk::signature::KeypairUtil;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::fs::remove_file;
use std::fs::File;
use std::io::Read;
@ -124,7 +124,7 @@ mod tests {
Entry::new_mut(
&mut id,
&mut num_hashes,
vec![SystemTransaction::new_user_account(
vec![system_transaction::create_user_account(
&keypair,
&keypair.pubkey(),
1,

8
core/src/cluster_tests.rs
View File

@ -12,7 +12,7 @@ use crate::poh_service::PohServiceConfig;
use solana_client::thin_client::create_client;
use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::{
duration_as_ms, DEFAULT_TICKS_PER_SLOT, NUM_CONSECUTIVE_LEADER_SLOTS, NUM_TICKS_PER_SECOND,
};
@ -37,7 +37,7 @@ pub fn spend_and_verify_all_nodes(
.poll_get_balance(&funding_keypair.pubkey())
.expect("balance in source");
assert!(bal > 0);
let mut transaction = SystemTransaction::new_transfer(
let mut transaction = system_transaction::transfer(
&funding_keypair,
&random_keypair.pubkey(),
1,
@ -63,7 +63,7 @@ pub fn send_many_transactions(node: &ContactInfo, funding_keypair: &Keypair, num
.poll_get_balance(&funding_keypair.pubkey())
.expect("balance in source");
assert!(bal > 0);
let mut transaction = SystemTransaction::new_transfer(
let mut transaction = system_transaction::transfer(
&funding_keypair,
&random_keypair.pubkey(),
1,
@ -183,7 +183,7 @@ pub fn kill_entry_and_spend_and_verify_rest(
}
let random_keypair = Keypair::new();
let mut transaction = SystemTransaction::new_transfer(
let mut transaction = system_transaction::transfer(
&funding_keypair,
&random_keypair.pubkey(),
1,

26
core/src/entry.rs
View File

@ -8,7 +8,7 @@ use crate::result::Result;
use bincode::{deserialize, serialized_size};
use chrono::prelude::Utc;
use rayon::prelude::*;
use solana_budget_api::budget_instruction::BudgetInstruction;
use solana_budget_api::budget_instruction;
use solana_sdk::hash::{Hash, Hasher};
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::transaction::Transaction;
@ -380,7 +380,7 @@ pub fn make_tiny_test_entries_from_hash(start: &Hash, num: usize) -> Vec<Entry>
let mut num_hashes = 0;
(0..num)
.map(|_| {
let ix = BudgetInstruction::new_apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
let ix = budget_instruction::apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
let tx = Transaction::new_signed_instructions(&[&keypair], vec![ix], *start);
Entry::new_mut(&mut hash, &mut num_hashes, vec![tx])
})
@ -399,7 +399,7 @@ pub fn make_large_test_entries(num_entries: usize) -> Vec<Entry> {
let keypair = Keypair::new();
let pubkey = keypair.pubkey();
let ix = BudgetInstruction::new_apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
let ix = budget_instruction::apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
let tx = Transaction::new_signed_instructions(&[&keypair], vec![ix], one);
let serialized_size = serialized_size(&tx).unwrap();
@ -450,31 +450,31 @@ mod tests {
use crate::packet::{to_blobs, BLOB_DATA_SIZE, PACKET_DATA_SIZE};
use solana_sdk::hash::hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use solana_sdk::system_transaction;
use solana_vote_api::vote_instruction::{self, Vote};
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
fn create_sample_payment(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ixs = BudgetInstruction::new_payment(&pubkey, &pubkey, 1);
let ixs = budget_instruction::payment(&pubkey, &pubkey, 1);
Transaction::new_signed_instructions(&[keypair], ixs, hash)
}
fn create_sample_timestamp(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ix = BudgetInstruction::new_apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
let ix = budget_instruction::apply_timestamp(&pubkey, &pubkey, &pubkey, Utc::now());
Transaction::new_signed_instructions(&[keypair], vec![ix], hash)
}
fn create_sample_signature(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ix = BudgetInstruction::new_apply_signature(&pubkey, &pubkey, &pubkey);
let ix = budget_instruction::apply_signature(&pubkey, &pubkey, &pubkey);
Transaction::new_signed_instructions(&[keypair], vec![ix], hash)
}
fn create_sample_vote(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ix = VoteInstruction::new_vote(&pubkey, Vote::new(1));
let ix = vote_instruction::vote(&pubkey, Vote::new(1));
Transaction::new_signed_instructions(&[keypair], vec![ix], hash)
}
@ -494,8 +494,8 @@ mod tests {
// First, verify entries
let keypair = Keypair::new();
let tx0 = SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
let tx1 = SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 1, zero, 0);
let tx0 = system_transaction::create_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
let tx1 = system_transaction::create_user_account(&keypair, &keypair.pubkey(), 1, zero, 0);
let mut e0 = Entry::new(&zero, 0, vec![tx0.clone(), tx1.clone()]);
assert!(e0.verify(&zero));
@ -545,7 +545,7 @@ mod tests {
fn test_next_entry_panic() {
let zero = Hash::default();
let keypair = Keypair::new();
let tx = SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
let tx = system_transaction::create_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
next_entry(&zero, 0, vec![tx]);
}
@ -553,7 +553,7 @@ mod tests {
fn test_serialized_size() {
let zero = Hash::default();
let keypair = Keypair::new();
let tx = SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
let tx = system_transaction::create_user_account(&keypair, &keypair.pubkey(), 0, zero, 0);
let entry = next_entry(&zero, 1, vec![tx.clone()]);
assert_eq!(
Entry::serialized_size(&[tx]),

10
core/src/fullnode.rs
View File

@ -25,10 +25,10 @@ use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::timestamp;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use solana_vote_api::vote_instruction::{self, Vote};
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver};
@ -318,7 +318,7 @@ pub fn make_active_set_entries(
num_ending_ticks: u64,
) -> (Vec<Entry>, Keypair) {
// 1) Assume the active_keypair node has no lamports staked
let transfer_tx = SystemTransaction::new_user_account(
let transfer_tx = system_transaction::create_user_account(
&lamport_source,
&active_keypair.pubkey(),
stake,
@ -332,7 +332,7 @@ pub fn make_active_set_entries(
let voting_keypair = Keypair::new();
let vote_account_id = voting_keypair.pubkey();
let new_vote_account_ixs = VoteInstruction::new_account(
let new_vote_account_ixs = vote_instruction::create_account(
&active_keypair.pubkey(),
&vote_account_id,
stake.saturating_sub(2),
@ -345,7 +345,7 @@ pub fn make_active_set_entries(
let new_vote_account_entry = next_entry_mut(&mut last_entry_hash, 1, vec![new_vote_account_tx]);
// 3) Create vote entry
let vote_ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(slot_to_vote_on));
let vote_ix = vote_instruction::vote(&voting_keypair.pubkey(), Vote::new(slot_to_vote_on));
let vote_tx =
Transaction::new_signed_instructions(&[&voting_keypair], vec![vote_ix], *blockhash);
let vote_entry = next_entry_mut(&mut last_entry_hash, 1, vec![vote_tx]);

15
core/src/local_cluster.rs
View File

@ -11,11 +11,11 @@ use solana_client::thin_client::ThinClient;
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::DEFAULT_SLOTS_PER_EPOCH;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_instruction;
use solana_vote_api::vote_state::VoteState;
use std::collections::HashMap;
use std::fs::remove_dir_all;
@ -296,7 +296,7 @@ impl LocalCluster {
) -> u64 {
trace!("getting leader blockhash");
let blockhash = client.get_recent_blockhash().unwrap();
let mut tx = SystemTransaction::new_user_account(
let mut tx = system_transaction::create_user_account(
&source_keypair,
dest_pubkey,
lamports,
@ -328,8 +328,11 @@ impl LocalCluster {
// Create the vote account if necessary
if client.poll_get_balance(&vote_account_pubkey).unwrap_or(0) == 0 {
// 1) Create vote account
let instructions =
VoteInstruction::new_account(&from_account.pubkey(), &vote_account_pubkey, amount);
let instructions = vote_instruction::create_account(
&from_account.pubkey(),
&vote_account_pubkey,
amount,
);
let mut transaction = Transaction::new_signed_instructions(
&[from_account.as_ref()],
instructions,
@ -345,7 +348,7 @@ impl LocalCluster {
// 2) Set delegate for new vote account
let vote_instruction =
VoteInstruction::new_delegate_stake(&vote_account_pubkey, &delegate_id);
vote_instruction::delegate_stake(&vote_account_pubkey, &delegate_id);
let mut transaction = Transaction::new_signed_instructions(
&[vote_account],

4
core/src/packet.rs
View File

@ -573,7 +573,7 @@ mod tests {
use rand::Rng;
use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::io;
use std::io::Write;
use std::net::{Ipv4Addr, SocketAddr, UdpSocket};
@ -612,7 +612,7 @@ mod tests {
fn test_to_packets() {
let keypair = Keypair::new();
let hash = Hash::new(&[1; 32]);
let tx = SystemTransaction::new_user_account(&keypair, &keypair.pubkey(), 1, hash, 0);
let tx = system_transaction::create_user_account(&keypair, &keypair.pubkey(), 1, hash, 0);
let rv = to_packets(&vec![tx.clone(); 1]);
assert_eq!(rv.len(), 1);
assert_eq!(rv[0].read().unwrap().packets.len(), 1);

6
core/src/replay_stage.rs
View File

@ -21,7 +21,7 @@ use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::KeypairUtil;
use solana_sdk::timing::{self, duration_as_ms};
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use solana_vote_api::vote_instruction::{self, Vote};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender};
use std::sync::{Arc, Mutex, RwLock};
@ -296,7 +296,7 @@ impl ReplayStage {
T: 'static + KeypairUtil + Send + Sync,
{
if let Some(ref voting_keypair) = voting_keypair {
let vote_ix = VoteInstruction::new_vote(&vote_account, Vote::new(bank.slot()));
let vote_ix = vote_instruction::vote(&vote_account, Vote::new(bank.slot()));
let vote_tx = Transaction::new_signed_instructions(
&[voting_keypair.as_ref()],
vec![vote_ix],
@ -635,7 +635,7 @@ mod test {
ledger_writer_sender,
);
let vote_ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(0));
let vote_ix = vote_instruction::vote(&voting_keypair.pubkey(), Vote::new(0));
let vote_tx = Transaction::new_signed_instructions(
&[voting_keypair.as_ref()],
vec![vote_ix],

8
core/src/replicator.rs
View File

@ -22,9 +22,9 @@ use solana_client::thin_client::{create_client, ThinClient};
use solana_drone::drone::{request_airdrop_transaction, DRONE_PORT};
use solana_sdk::hash::{Hash, Hasher};
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use solana_storage_api::storage_instruction::StorageInstruction;
use solana_storage_api::storage_instruction;
use std::fs::File;
use std::io;
use std::io::BufReader;
@ -434,7 +434,7 @@ impl Replicator {
{
let blockhash = client.get_recent_blockhash().expect("blockhash");
//TODO the account space needs to be well defined somewhere
let tx = SystemTransaction::new_account(
let tx = system_transaction::create_account(
keypair,
&storage_keypair.pubkey(),
blockhash,
@ -455,7 +455,7 @@ impl Replicator {
);
Self::get_airdrop_lamports(&client, &self.keypair, &self.cluster_entrypoint);
let ix = StorageInstruction::new_mining_proof(
let ix = storage_instruction::mining_proof(
&self.storage_keypair.pubkey(),
self.hash,
self.slot,

21
core/src/rpc.rs
View File

@ -454,7 +454,7 @@ mod tests {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::{hash, Hash};
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::thread;
fn start_rpc_handler_with_tx(pubkey: &Pubkey) -> (MetaIoHandler<Meta>, Meta, Hash, Keypair) {
@ -463,7 +463,7 @@ mod tests {
let exit = Arc::new(AtomicBool::new(false));
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_transfer(&alice, pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, pubkey, 20, blockhash, 0);
bank.process_transaction(&tx).expect("process transaction");
let request_processor = Arc::new(RwLock::new(JsonRpcRequestProcessor::new(
@ -503,7 +503,7 @@ mod tests {
);
thread::spawn(move || {
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
bank.process_transaction(&tx).expect("process transaction");
})
.join()
@ -575,7 +575,7 @@ mod tests {
fn test_rpc_confirm_tx() {
let bob_pubkey = Pubkey::new_rand();
let (io, meta, blockhash, alice) = start_rpc_handler_with_tx(&bob_pubkey);
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let req = format!(
r#"{{"jsonrpc":"2.0","id":1,"method":"confirmTransaction","params":["{}"]}}"#,
@ -594,7 +594,7 @@ mod tests {
fn test_rpc_get_signature_status() {
let bob_pubkey = Pubkey::new_rand();
let (io, meta, blockhash, alice) = start_rpc_handler_with_tx(&bob_pubkey);
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let req = format!(
r#"{{"jsonrpc":"2.0","id":1,"method":"getSignatureStatus","params":["{}"]}}"#,
@ -609,7 +609,7 @@ mod tests {
assert_eq!(expected, result);
// Test getSignatureStatus request on unprocessed tx
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 10, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 10, blockhash, 0);
let req = format!(
r#"{{"jsonrpc":"2.0","id":1,"method":"getSignatureStatus","params":["{}"]}}"#,
tx.signatures[0]
@ -716,13 +716,8 @@ mod tests {
#[test]
fn test_rpc_verify_signature() {
let tx = SystemTransaction::new_transfer(
&Keypair::new(),
&Pubkey::new_rand(),
20,
hash(&[0]),
0,
);
let tx =
system_transaction::transfer(&Keypair::new(), &Pubkey::new_rand(), 20, hash(&[0]), 0);
assert_eq!(
verify_signature(&tx.signatures[0].to_string()).unwrap(),
tx.signatures[0]

24
core/src/rpc_pubsub.rs
View File

@ -227,12 +227,12 @@ mod tests {
use jsonrpc_core::Response;
use jsonrpc_pubsub::{PubSubHandler, Session};
use solana_budget_api;
use solana_budget_api::budget_instruction::BudgetInstruction;
use solana_budget_api::budget_instruction;
use solana_runtime::bank::{self, Bank};
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use std::thread::sleep;
use std::time::Duration;
@ -270,7 +270,7 @@ mod tests {
let rpc = RpcSolPubSubImpl::default();
// Test signature subscriptions
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let session = create_session();
let (subscriber, _id_receiver, mut receiver) =
@ -302,7 +302,7 @@ mod tests {
let rpc = RpcSolPubSubImpl::default();
io.extend_with(rpc.to_delegate());
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let req = format!(
r#"{{"jsonrpc":"2.0","id":1,"method":"signatureSubscribe","params":["{}"]}}"#,
tx.signatures[0].to_string()
@ -354,11 +354,16 @@ mod tests {
let (subscriber, _id_receiver, mut receiver) = Subscriber::new_test("accountNotification");
rpc.account_subscribe(session, subscriber, contract_state.pubkey().to_string());
let tx =
SystemTransaction::new_user_account(&alice, &contract_funds.pubkey(), 51, blockhash, 0);
let tx = system_transaction::create_user_account(
&alice,
&contract_funds.pubkey(),
51,
blockhash,
0,
);
let arc_bank = process_transaction_and_notify(&arc_bank, &tx, &rpc.subscriptions).unwrap();
let ixs = BudgetInstruction::new_when_signed(
let ixs = budget_instruction::when_signed(
&contract_funds.pubkey(),
&bob_pubkey,
&contract_state.pubkey(),
@ -391,10 +396,11 @@ mod tests {
assert_eq!(serde_json::to_string(&expected).unwrap(), response);
}
let tx = SystemTransaction::new_user_account(&alice, &witness.pubkey(), 1, blockhash, 0);
let tx =
system_transaction::create_user_account(&alice, &witness.pubkey(), 1, blockhash, 0);
let arc_bank = process_transaction_and_notify(&arc_bank, &tx, &rpc.subscriptions).unwrap();
sleep(Duration::from_millis(200));
let ix = BudgetInstruction::new_apply_signature(
let ix = budget_instruction::apply_signature(
&witness.pubkey(),
&contract_state.pubkey(),
&bob_pubkey,

8
core/src/rpc_subscriptions.rs
View File

@ -202,7 +202,7 @@ mod tests {
use solana_budget_api;
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use tokio::prelude::{Async, Stream};
#[test]
@ -211,7 +211,7 @@ mod tests {
let bank = Bank::new(&genesis_block);
let alice = Keypair::new();
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_account(
let tx = system_transaction::create_account(
&mint_keypair,
&alice.pubkey(),
blockhash,
@ -257,7 +257,7 @@ mod tests {
let bank = Bank::new(&genesis_block);
let alice = Keypair::new();
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_account(
let tx = system_transaction::create_account(
&mint_keypair,
&alice.pubkey(),
blockhash,
@ -302,7 +302,7 @@ mod tests {
let bank = Bank::new(&genesis_block);
let alice = Keypair::new();
let blockhash = bank.last_blockhash();
let tx = SystemTransaction::new_transfer(&mint_keypair, &alice.pubkey(), 20, blockhash, 0);
let tx = system_transaction::transfer(&mint_keypair, &alice.pubkey(), 20, blockhash, 0);
let signature = tx.signatures[0];
bank.process_transaction(&tx).unwrap();

10
core/src/storage_stage.rs
View File

@ -16,9 +16,9 @@ use solana_client::thin_client::{create_client_with_timeout, ThinClient};
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use solana_storage_api::storage_instruction::StorageInstruction;
use solana_storage_api::storage_instruction::{self, StorageInstruction};
use std::collections::HashSet;
use std::io;
use std::mem::size_of;
@ -279,7 +279,7 @@ impl StorageStage {
if let Some(account) = account_to_create {
if client.get_account_data(&account).is_err() {
// TODO the account space needs to be well defined somewhere
let tx = SystemTransaction::new_account(
let tx = system_transaction::create_account(
keypair,
&storage_keypair.pubkey(),
blockhash,
@ -318,7 +318,7 @@ impl StorageStage {
let mut seed = [0u8; 32];
let signature = keypair.sign(&entry_id.as_ref());
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&keypair.pubkey(),
entry_id,
entry_height,
@ -643,7 +643,7 @@ mod tests {
}
let keypair = Keypair::new();
let mining_proof_ix = StorageInstruction::new_mining_proof(
let mining_proof_ix = storage_instruction::mining_proof(
&keypair.pubkey(),
Hash::default(),
0,

12
core/src/test_tx.rs
View File

@ -3,14 +3,14 @@ use solana_sdk::instruction::CompiledInstruction;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_program;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
pub fn test_tx() -> Transaction {
let keypair1 = Keypair::new();
let pubkey1 = keypair1.pubkey();
let zero = Hash::default();
SystemTransaction::new_user_account(&keypair1, &pubkey1, 42, zero, 0)
system_transaction::create_user_account(&keypair1, &pubkey1, 42, zero, 0)
}
pub fn test_multisig_tx() -> Transaction {
@ -20,11 +20,15 @@ pub fn test_multisig_tx() -> Transaction {
let lamports = 5;
let blockhash = Hash::default();
let system_instruction = SystemInstruction::Transfer { lamports };
let transfer_instruction = SystemInstruction::Transfer { lamports };
let program_ids = vec![system_program::id(), solana_budget_api::id()];
let instructions = vec![CompiledInstruction::new(0, &system_instruction, vec![0, 1])];
let instructions = vec![CompiledInstruction::new(
0,
&transfer_instruction,
vec![0, 1],
)];
Transaction::new_with_compiled_instructions(
&keypairs,

17
core/src/voting_keypair.rs
View File

@ -110,7 +110,7 @@ pub mod tests {
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use solana_vote_api::vote_instruction::{self, Vote};
fn process_instructions<T: KeypairUtil>(bank: &Bank, keypairs: &[&T], ixs: Vec<Instruction>) {
let blockhash = bank.last_blockhash();
@ -124,7 +124,7 @@ pub mod tests {
bank: &Bank,
lamports: u64,
) {
let ixs = VoteInstruction::new_account(&from_keypair.pubkey(), voting_pubkey, lamports);
let ixs = vote_instruction::create_account(&from_keypair.pubkey(), voting_pubkey, lamports);
process_instructions(bank, &[from_keypair], ixs);
}
@ -137,16 +137,13 @@ pub mod tests {
) {
let voting_pubkey = voting_keypair.pubkey();
let mut ixs =
VoteInstruction::new_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(VoteInstruction::new_delegate_stake(
&voting_pubkey,
delegate,
));
vote_instruction::create_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(vote_instruction::delegate_stake(&voting_pubkey, delegate));
process_instructions(bank, &[from_keypair, voting_keypair], ixs);
}
pub fn push_vote<T: KeypairUtil>(voting_keypair: &T, bank: &Bank, slot: u64) {
let ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(slot));
let ix = vote_instruction::vote(&voting_keypair.pubkey(), Vote::new(slot));
process_instructions(bank, &[voting_keypair], vec![ix]);
}
@ -159,8 +156,8 @@ pub mod tests {
) {
let voting_pubkey = voting_keypair.pubkey();
let mut ixs =
VoteInstruction::new_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(VoteInstruction::new_vote(&voting_pubkey, Vote::new(slot)));
vote_instruction::create_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(vote_instruction::vote(&voting_pubkey, Vote::new(slot)));
process_instructions(bank, &[from_keypair, voting_keypair], ixs);
}
}

4
core/tests/rpc.rs
View File

@ -7,7 +7,7 @@ use solana::fullnode::new_fullnode_for_tests;
use solana_client::rpc_client::get_rpc_request_str;
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::fs::remove_dir_all;
use std::thread::sleep;
use std::time::Duration;
@ -41,7 +41,7 @@ fn test_rpc_send_tx() {
let blockhash = Hash::new(&blockhash_vec);
info!("blockhash: {:?}", blockhash);
let tx = SystemTransaction::new_transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash, 0);
let serial_tx = serialize(&tx).unwrap();
let client = reqwest::Client::new();

4
core/tests/tvu.rs
View File

@ -18,7 +18,7 @@ use solana::streamer;
use solana::tvu::{Sockets, Tvu};
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use std::fs::remove_dir_all;
use std::net::UdpSocket;
use std::sync::atomic::{AtomicBool, Ordering};
@ -140,7 +140,7 @@ fn test_replay() {
let entry0 = next_entry_mut(&mut cur_hash, i, vec![]);
let entry_tick0 = next_entry_mut(&mut cur_hash, i + 1, vec![]);
let tx0 = SystemTransaction::new_user_account(
let tx0 = system_transaction::create_user_account(
&mint_keypair,
&bob_keypair.pubkey(),
transfer_amount,

7
drone/src/drone.rs
View File

@ -16,7 +16,7 @@ use solana_sdk::message::Message;
use solana_sdk::packet::PACKET_DATA_SIZE;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use solana_sdk::transaction::Transaction;
use std::io;
use std::io::{Error, ErrorKind};
@ -127,7 +127,7 @@ impl Drone {
info!("Requesting airdrop of {} to {:?}", lamports, to);
let create_instruction = SystemInstruction::new_user_account(
let create_instruction = system_instruction::create_user_account(
&self.mint_keypair.pubkey(),
&to,
lamports,
@ -285,6 +285,7 @@ pub fn run_local_drone(mint_keypair: Keypair, sender: Sender<SocketAddr>) {
mod tests {
use super::*;
use bytes::BufMut;
use solana_sdk::system_instruction::SystemInstruction;
use std::time::Duration;
#[test]
@ -394,7 +395,7 @@ mod tests {
let keypair = Keypair::new();
let expected_instruction =
SystemInstruction::new_user_account(&keypair.pubkey(), &to, lamports);
system_instruction::create_user_account(&keypair.pubkey(), &to, lamports);
let message = Message::new(vec![expected_instruction]);
let expected_tx = Transaction::new(&[&keypair], message, blockhash);
let expected_bytes = serialize(&expected_tx).unwrap();

4
drone/src/drone_mock.rs
View File

@ -1,7 +1,7 @@
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use std::io::{Error, ErrorKind};
use std::net::SocketAddr;
@ -18,6 +18,6 @@ pub fn request_airdrop_transaction(
let key = Keypair::new();
let to = Pubkey::new_rand();
let blockhash = Hash::default();
let tx = SystemTransaction::new_user_account(&key, &to, lamports, blockhash, 0);
let tx = system_transaction::create_user_account(&key, &to, lamports, blockhash, 0);
Ok(tx)
}

5
drone/tests/local-drone.rs
View File

@ -3,7 +3,7 @@ use solana_sdk::hash::Hash;
use solana_sdk::message::Message;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use solana_sdk::transaction::Transaction;
use std::sync::mpsc::channel;
@ -13,7 +13,8 @@ fn test_local_drone() {
let to = Pubkey::new_rand();
let lamports = 50;
let blockhash = Hash::new(&to.as_ref());
let create_instruction = SystemInstruction::new_user_account(&keypair.pubkey(), &to, lamports);
let create_instruction =
system_instruction::create_user_account(&keypair.pubkey(), &to, lamports);
let message = Message::new(vec![create_instruction]);
let expected_tx = Transaction::new(&[&keypair], message, blockhash);

6
install/src/command.rs
View File

@ -5,7 +5,7 @@ use console::{style, Emoji};
use indicatif::{ProgressBar, ProgressStyle};
use ring::digest::{Context, Digest, SHA256};
use solana_client::rpc_client::RpcClient;
use solana_config_api::ConfigInstruction;
use solana_config_api::config_instruction;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{read_keypair, Keypair, KeypairUtil, Signable};
use solana_sdk::transaction::Transaction;
@ -198,7 +198,7 @@ fn new_update_manifest(
{
let recect_blockhash = rpc_client.get_recent_blockhash()?;
let new_account = ConfigInstruction::new_account::<SignedUpdateManifest>(
let new_account = config_instruction::create_account::<SignedUpdateManifest>(
&from_keypair.pubkey(),
&update_manifest_keypair.pubkey(),
1, // lamports
@ -220,7 +220,7 @@ fn store_update_manifest(
) -> Result<(), Box<dyn std::error::Error>> {
let recect_blockhash = rpc_client.get_recent_blockhash()?;
let new_store = ConfigInstruction::new_store::<SignedUpdateManifest>(
let new_store = config_instruction::store::<SignedUpdateManifest>(
&from_keypair.pubkey(),
&update_manifest_keypair.pubkey(),
update_manifest,

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

@ -6,7 +6,7 @@ use chrono::prelude::{DateTime, Utc};
use serde_derive::{Deserialize, Serialize};
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
/// A smart contract.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
@ -30,93 +30,90 @@ pub enum BudgetInstruction {
ApplySignature,
}
impl BudgetInstruction {
fn new_initialize_account(contract: &Pubkey, expr: BudgetExpr) -> Instruction {
let mut keys = vec![];
if let BudgetExpr::Pay(payment) = &expr {
keys.push(AccountMeta::new(payment.to, false));
}
keys.push(AccountMeta::new(*contract, false));
Instruction::new(id(), &BudgetInstruction::InitializeAccount(expr), keys)
fn initialize_account(contract: &Pubkey, expr: BudgetExpr) -> Instruction {
let mut keys = vec![];
if let BudgetExpr::Pay(payment) = &expr {
keys.push(AccountMeta::new(payment.to, false));
}
keys.push(AccountMeta::new(*contract, false));
Instruction::new(id(), &BudgetInstruction::InitializeAccount(expr), keys)
}
pub fn new_account(
from: &Pubkey,
contract: &Pubkey,
lamports: u64,
expr: BudgetExpr,
) -> Vec<Instruction> {
if !expr.verify(lamports) {
panic!("invalid budget expression");
}
let space = serialized_size(&BudgetState::new(expr.clone())).unwrap();
vec![
SystemInstruction::new_account(&from, contract, lamports, space, &id()),
BudgetInstruction::new_initialize_account(contract, expr),
]
pub fn create_account(
from: &Pubkey,
contract: &Pubkey,
lamports: u64,
expr: BudgetExpr,
) -> Vec<Instruction> {
if !expr.verify(lamports) {
panic!("invalid budget expression");
}
let space = serialized_size(&BudgetState::new(expr.clone())).unwrap();
vec![
system_instruction::create_account(&from, contract, lamports, space, &id()),
initialize_account(contract, expr),
]
}
/// Create a new payment script.
pub fn new_payment(from: &Pubkey, to: &Pubkey, lamports: u64) -> Vec<Instruction> {
let contract = Pubkey::new_rand();
let expr = BudgetExpr::new_payment(lamports, to);
Self::new_account(from, &contract, lamports, expr)
}
/// Create a new payment script.
pub fn payment(from: &Pubkey, to: &Pubkey, lamports: u64) -> Vec<Instruction> {
let contract = Pubkey::new_rand();
let expr = BudgetExpr::new_payment(lamports, to);
create_account(from, &contract, lamports, expr)
}
/// Create a future payment script.
pub fn new_on_date(
from: &Pubkey,
to: &Pubkey,
contract: &Pubkey,
dt: DateTime<Utc>,
dt_pubkey: &Pubkey,
cancelable: Option<Pubkey>,
lamports: u64,
) -> Vec<Instruction> {
let expr =
BudgetExpr::new_cancelable_future_payment(dt, dt_pubkey, lamports, to, cancelable);
Self::new_account(from, contract, lamports, expr)
}
/// Create a future payment script.
pub fn on_date(
from: &Pubkey,
to: &Pubkey,
contract: &Pubkey,
dt: DateTime<Utc>,
dt_pubkey: &Pubkey,
cancelable: Option<Pubkey>,
lamports: u64,
) -> Vec<Instruction> {
let expr = BudgetExpr::new_cancelable_future_payment(dt, dt_pubkey, lamports, to, cancelable);
create_account(from, contract, lamports, expr)
}
/// Create a multisig payment script.
pub fn new_when_signed(
from: &Pubkey,
to: &Pubkey,
contract: &Pubkey,
witness: &Pubkey,
cancelable: Option<Pubkey>,
lamports: u64,
) -> Vec<Instruction> {
let expr = BudgetExpr::new_cancelable_authorized_payment(witness, lamports, to, cancelable);
Self::new_account(from, contract, lamports, expr)
}
/// Create a multisig payment script.
pub fn when_signed(
from: &Pubkey,
to: &Pubkey,
contract: &Pubkey,
witness: &Pubkey,
cancelable: Option<Pubkey>,
lamports: u64,
) -> Vec<Instruction> {
let expr = BudgetExpr::new_cancelable_authorized_payment(witness, lamports, to, cancelable);
create_account(from, contract, lamports, expr)
}
pub fn new_apply_timestamp(
from: &Pubkey,
contract: &Pubkey,
to: &Pubkey,
dt: DateTime<Utc>,
) -> Instruction {
let mut account_metas = vec![
AccountMeta::new(*from, true),
AccountMeta::new(*contract, false),
];
if from != to {
account_metas.push(AccountMeta::new(*to, false));
}
Instruction::new(id(), &BudgetInstruction::ApplyTimestamp(dt), account_metas)
pub fn apply_timestamp(
from: &Pubkey,
contract: &Pubkey,
to: &Pubkey,
dt: DateTime<Utc>,
) -> Instruction {
let mut account_metas = vec![
AccountMeta::new(*from, true),
AccountMeta::new(*contract, false),
];
if from != to {
account_metas.push(AccountMeta::new(*to, false));
}
Instruction::new(id(), &BudgetInstruction::ApplyTimestamp(dt), account_metas)
}
pub fn new_apply_signature(from: &Pubkey, contract: &Pubkey, to: &Pubkey) -> Instruction {
let mut account_metas = vec![
AccountMeta::new(*from, true),
AccountMeta::new(*contract, false),
];
if from != to {
account_metas.push(AccountMeta::new(*to, false));
}
Instruction::new(id(), &BudgetInstruction::ApplySignature, account_metas)
pub fn apply_signature(from: &Pubkey, contract: &Pubkey, to: &Pubkey) -> Instruction {
let mut account_metas = vec![
AccountMeta::new(*from, true),
AccountMeta::new(*contract, false),
];
if from != to {
account_metas.push(AccountMeta::new(*to, false));
}
Instruction::new(id(), &BudgetInstruction::ApplySignature, account_metas)
}
#[cfg(test)]
@ -128,7 +125,7 @@ mod tests {
fn test_budget_instruction_verify() {
let alice_pubkey = Pubkey::new_rand();
let bob_pubkey = Pubkey::new_rand();
BudgetInstruction::new_payment(&alice_pubkey, &bob_pubkey, 1); // No panic! indicates success.
payment(&alice_pubkey, &bob_pubkey, 1); // No panic! indicates success.
}
#[test]
@ -138,7 +135,7 @@ mod tests {
let bob_pubkey = Pubkey::new_rand();
let budget_pubkey = Pubkey::new_rand();
let expr = BudgetExpr::new_payment(2, &bob_pubkey);
BudgetInstruction::new_account(&alice_pubkey, &budget_pubkey, 1, expr);
create_account(&alice_pubkey, &budget_pubkey, 1, expr);
}
#[test]
@ -148,6 +145,6 @@ mod tests {
let bob_pubkey = Pubkey::new_rand();
let budget_pubkey = Pubkey::new_rand();
let expr = BudgetExpr::new_payment(1, &bob_pubkey);
BudgetInstruction::new_account(&alice_pubkey, &budget_pubkey, 2, expr);
create_account(&alice_pubkey, &budget_pubkey, 2, expr);
}
}

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

@ -143,7 +143,7 @@ pub fn process_instruction(
#[cfg(test)]
mod tests {
use super::*;
use crate::budget_instruction::BudgetInstruction;
use crate::budget_instruction;
use crate::id;
use solana_runtime::bank::Bank;
use solana_runtime::bank_client::BankClient;
@ -166,7 +166,7 @@ mod tests {
let bank_client = BankClient::new(&bank);
let alice_pubkey = alice_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let instructions = BudgetInstruction::new_payment(&alice_pubkey, &bob_pubkey, 100);
let instructions = budget_instruction::payment(&alice_pubkey, &bob_pubkey, 100);
let message = Message::new(instructions);
bank_client
.process_message(&[&alice_keypair], message)
@ -184,7 +184,7 @@ mod tests {
let budget_pubkey = Pubkey::new_rand();
let bob_pubkey = Pubkey::new_rand();
let witness = Pubkey::new_rand();
let instructions = BudgetInstruction::new_when_signed(
let instructions = budget_instruction::when_signed(
&alice_pubkey,
&bob_pubkey,
&budget_pubkey,
@ -204,7 +204,7 @@ mod tests {
.transfer(1, &alice_keypair, &mallory_pubkey)
.unwrap();
let instruction =
BudgetInstruction::new_apply_signature(&mallory_pubkey, &budget_pubkey, &bob_pubkey);
budget_instruction::apply_signature(&mallory_pubkey, &budget_pubkey, &bob_pubkey);
let mut message = Message::new(vec![instruction]);
// Attack! Part 2: Point the instruction to the expected, but unsigned, key.
@ -231,7 +231,7 @@ mod tests {
let budget_pubkey = Pubkey::new_rand();
let bob_pubkey = Pubkey::new_rand();
let dt = Utc::now();
let instructions = BudgetInstruction::new_on_date(
let instructions = budget_instruction::on_date(
&alice_pubkey,
&bob_pubkey,
&budget_pubkey,
@ -251,12 +251,8 @@ mod tests {
bank_client
.transfer(1, &alice_keypair, &mallory_pubkey)
.unwrap();
let instruction = BudgetInstruction::new_apply_timestamp(
&mallory_pubkey,
&budget_pubkey,
&bob_pubkey,
dt,
);
let instruction =
budget_instruction::apply_timestamp(&mallory_pubkey, &budget_pubkey, &bob_pubkey, dt);
let mut message = Message::new(vec![instruction]);
// Attack! Part 2: Point the instruction to the expected, but unsigned, key.
@ -282,7 +278,7 @@ mod tests {
let bob_pubkey = Pubkey::new_rand();
let mallory_pubkey = Pubkey::new_rand();
let dt = Utc::now();
let instructions = BudgetInstruction::new_on_date(
let instructions = budget_instruction::on_date(
&alice_pubkey,
&bob_pubkey,
&budget_pubkey,
@ -303,12 +299,8 @@ mod tests {
assert!(budget_state.is_pending());
// Attack! Try to payout to mallory_pubkey
let instruction = BudgetInstruction::new_apply_timestamp(
&alice_pubkey,
&budget_pubkey,
&mallory_pubkey,
dt,
);
let instruction =
budget_instruction::apply_timestamp(&alice_pubkey, &budget_pubkey, &mallory_pubkey, dt);
assert_eq!(
bank_client
.process_instruction(&alice_keypair, instruction)
@ -329,7 +321,7 @@ mod tests {
// Now, acknowledge the time in the condition occurred and
// that pubkey's funds are now available.
let instruction =
BudgetInstruction::new_apply_timestamp(&alice_pubkey, &budget_pubkey, &bob_pubkey, dt);
budget_instruction::apply_timestamp(&alice_pubkey, &budget_pubkey, &bob_pubkey, dt);
bank_client
.process_instruction(&alice_keypair, instruction)
.unwrap();
@ -348,7 +340,7 @@ mod tests {
let bob_pubkey = Pubkey::new_rand();
let dt = Utc::now();
let instructions = BudgetInstruction::new_on_date(
let instructions = budget_instruction::on_date(
&alice_pubkey,
&bob_pubkey,
&budget_pubkey,
@ -377,7 +369,7 @@ mod tests {
assert_eq!(bank.get_balance(&alice_pubkey), 1);
let instruction =
BudgetInstruction::new_apply_signature(&mallory_pubkey, &budget_pubkey, &bob_pubkey);
budget_instruction::apply_signature(&mallory_pubkey, &budget_pubkey, &bob_pubkey);
bank_client
.process_instruction(&mallory_keypair, instruction)
.unwrap();
@ -388,7 +380,7 @@ mod tests {
// Now, cancel the transaction. mint gets her funds back
let instruction =
BudgetInstruction::new_apply_signature(&alice_pubkey, &budget_pubkey, &alice_pubkey);
budget_instruction::apply_signature(&alice_pubkey, &budget_pubkey, &alice_pubkey);
bank_client
.process_instruction(&alice_keypair, instruction)
.unwrap();

58
programs/config_api/src/config_instruction.rs
View File

@ -2,36 +2,32 @@ use crate::id;
use crate::ConfigState;
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
pub struct ConfigInstruction {}
impl ConfigInstruction {
/// Create a new, empty configuration account
pub fn new_account<T: ConfigState>(
from_account_pubkey: &Pubkey,
config_account_pubkey: &Pubkey,
lamports: u64,
) -> Instruction {
SystemInstruction::new_account(
from_account_pubkey,
config_account_pubkey,
lamports,
T::max_space(),
&id(),
)
}
/// Store new data in a configuration account
pub fn new_store<T: ConfigState>(
from_account_pubkey: &Pubkey,
config_account_pubkey: &Pubkey,
data: &T,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_account_pubkey, true),
AccountMeta::new(*config_account_pubkey, true),
];
Instruction::new(id(), data, account_metas)
}
/// Create a new, empty configuration account
pub fn create_account<T: ConfigState>(
from_account_pubkey: &Pubkey,
config_account_pubkey: &Pubkey,
lamports: u64,
) -> Instruction {
system_instruction::create_account(
from_account_pubkey,
config_account_pubkey,
lamports,
T::max_space(),
&id(),
)
}
/// Store new data in a configuration account
pub fn store<T: ConfigState>(
from_account_pubkey: &Pubkey,
config_account_pubkey: &Pubkey,
data: &T,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_account_pubkey, true),
AccountMeta::new(*config_account_pubkey, true),
];
Instruction::new(id(), data, account_metas)
}

25
programs/config_api/src/config_processor.rs
View File

@ -28,7 +28,7 @@ pub fn process_instruction(
#[cfg(test)]
mod tests {
use super::*;
use crate::{id, ConfigInstruction, ConfigState};
use crate::{config_instruction, id, ConfigState};
use bincode::{deserialize, serialized_size};
use serde_derive::{Deserialize, Serialize};
use solana_runtime::bank::Bank;
@ -36,7 +36,7 @@ mod tests {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::message::Message;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
#[derive(Serialize, Deserialize, Default, Debug, PartialEq)]
struct MyConfig {
@ -78,7 +78,7 @@ mod tests {
bank_client
.process_instruction(
&mint_keypair,
ConfigInstruction::new_account::<MyConfig>(
config_instruction::create_account::<MyConfig>(
&mint_keypair.pubkey(),
&config_pubkey,
1,
@ -111,7 +111,7 @@ mod tests {
let my_config = MyConfig::new(42);
let instruction =
ConfigInstruction::new_store(&from_keypair.pubkey(), &config_pubkey, &my_config);
config_instruction::store(&from_keypair.pubkey(), &config_pubkey, &my_config);
let message = Message::new(vec![instruction]);
bank_client
.process_message(&[&from_keypair, &config_keypair], message)
@ -133,11 +133,8 @@ mod tests {
let my_config = MyConfig::new(42);
// Replace instruction data with a vector that's too large
let mut instruction = ConfigInstruction::new_store(
&from_keypair.pubkey(),
&config_keypair.pubkey(),
&my_config,
);
let mut instruction =
config_instruction::store(&from_keypair.pubkey(), &config_keypair.pubkey(), &my_config);
instruction.data = vec![0; 123];
let message = Message::new(vec![instruction]);
@ -155,14 +152,10 @@ mod tests {
bank.transfer(42, &mint_keypair, &system_pubkey).unwrap();
let (bank_client, from_keypair, config_keypair) = create_config_client(&bank, mint_keypair);
let move_instruction =
SystemInstruction::new_transfer(&system_pubkey, &Pubkey::default(), 42);
let move_instruction = system_instruction::transfer(&system_pubkey, &Pubkey::default(), 42);
let my_config = MyConfig::new(42);
let mut store_instruction = ConfigInstruction::new_store(
&from_keypair.pubkey(),
&config_keypair.pubkey(),
&my_config,
);
let mut store_instruction =
config_instruction::store(&from_keypair.pubkey(), &config_keypair.pubkey(), &my_config);
store_instruction.accounts[0].is_signer = false;
store_instruction.accounts[1].is_signer = false;

4
programs/config_api/src/lib.rs
View File

@ -1,11 +1,9 @@
use serde::Serialize;
use solana_sdk::pubkey::Pubkey;
mod config_instruction;
pub mod config_instruction;
pub mod config_processor;
pub use config_instruction::ConfigInstruction;
const CONFIG_PROGRAM_ID: [u8; 32] = [
133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,

167
programs/exchange_api/src/exchange_instruction.rs
View File

@ -59,89 +59,88 @@ pub enum ExchangeInstruction {
/// key 6 - Token account in which to deposit the brokers profit from the swap.
SwapRequest,
}
impl ExchangeInstruction {
pub fn new_account_request(owner: &Pubkey, new: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*new, false),
];
Instruction::new(id(), &ExchangeInstruction::AccountRequest, account_metas)
}
pub fn new_transfer_request(
owner: &Pubkey,
to: &Pubkey,
from: &Pubkey,
token: Token,
tokens: u64,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*to, false),
AccountMeta::new(*from, false),
];
Instruction::new(
id(),
&ExchangeInstruction::TransferRequest(token, tokens),
account_metas,
)
}
pub fn new_trade_request(
owner: &Pubkey,
trade: &Pubkey,
direction: Direction,
pair: TokenPair,
tokens: u64,
price: u64,
src_account: &Pubkey,
dst_account: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*trade, false),
AccountMeta::new(*src_account, false),
];
Instruction::new(
id(),
&ExchangeInstruction::TradeRequest(TradeRequestInfo {
direction,
pair,
tokens,
price,
dst_account: *dst_account,
}),
account_metas,
)
}
pub fn new_trade_cancellation(owner: &Pubkey, trade: &Pubkey, account: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*trade, false),
AccountMeta::new(*account, false),
];
Instruction::new(id(), &ExchangeInstruction::TradeCancellation, account_metas)
}
pub fn new_swap_request(
owner: &Pubkey,
swap: &Pubkey,
to_trade: &Pubkey,
from_trade: &Pubkey,
to_trade_account: &Pubkey,
from_trade_account: &Pubkey,
profit_account: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*swap, false),
AccountMeta::new(*to_trade, false),
AccountMeta::new(*from_trade, false),
AccountMeta::new(*to_trade_account, false),
AccountMeta::new(*from_trade_account, false),
AccountMeta::new(*profit_account, false),
];
Instruction::new(id(), &ExchangeInstruction::SwapRequest, account_metas)
}
pub fn account_request(owner: &Pubkey, new: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*new, false),
];
Instruction::new(id(), &ExchangeInstruction::AccountRequest, account_metas)
}
pub fn transfer_request(
owner: &Pubkey,
to: &Pubkey,
from: &Pubkey,
token: Token,
tokens: u64,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*to, false),
AccountMeta::new(*from, false),
];
Instruction::new(
id(),
&ExchangeInstruction::TransferRequest(token, tokens),
account_metas,
)
}
pub fn trade_request(
owner: &Pubkey,
trade: &Pubkey,
direction: Direction,
pair: TokenPair,
tokens: u64,
price: u64,
src_account: &Pubkey,
dst_account: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*trade, false),
AccountMeta::new(*src_account, false),
];
Instruction::new(
id(),
&ExchangeInstruction::TradeRequest(TradeRequestInfo {
direction,
pair,
tokens,
price,
dst_account: *dst_account,
}),
account_metas,
)
}
pub fn trade_cancellation(owner: &Pubkey, trade: &Pubkey, account: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*trade, false),
AccountMeta::new(*account, false),
];
Instruction::new(id(), &ExchangeInstruction::TradeCancellation, account_metas)
}
pub fn swap_request(
owner: &Pubkey,
swap: &Pubkey,
to_trade: &Pubkey,
from_trade: &Pubkey,
to_trade_account: &Pubkey,
from_trade_account: &Pubkey,
profit_account: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*owner, true),
AccountMeta::new(*swap, false),
AccountMeta::new(*to_trade, false),
AccountMeta::new(*from_trade, false),
AccountMeta::new(*to_trade_account, false),
AccountMeta::new(*from_trade_account, false),
AccountMeta::new(*profit_account, false),
];
Instruction::new(id(), &ExchangeInstruction::SwapRequest, account_metas)
}

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

@ -412,11 +412,12 @@ pub fn process_instruction(
#[cfg(test)]
mod test {
use super::*;
use crate::exchange_instruction;
use solana_runtime::bank::Bank;
use solana_runtime::bank_client::BankClient;
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use std::mem;
fn try_calc(
@ -527,7 +528,7 @@ mod test {
fn create_account(client: &BankClient, owner: &Keypair) -> Pubkey {
let new = Pubkey::new_rand();
let instruction = SystemInstruction::new_account(
let instruction = system_instruction::create_account(
&owner.pubkey(),
&new,
1,
@ -542,7 +543,7 @@ mod test {
fn create_token_account(client: &BankClient, owner: &Keypair) -> Pubkey {
let new = Pubkey::new_rand();
let instruction = SystemInstruction::new_account(
let instruction = system_instruction::create_account(
&owner.pubkey(),
&new,
1,
@ -552,7 +553,7 @@ mod test {
client
.process_instruction(owner, instruction)
.expect(&format!("{}:{}", line!(), file!()));
let instruction = ExchangeInstruction::new_account_request(&owner.pubkey(), &new);
let instruction = exchange_instruction::account_request(&owner.pubkey(), &new);
client
.process_instruction(owner, instruction)
.expect(&format!("{}:{}", line!(), file!()));
@ -561,7 +562,7 @@ mod test {
fn transfer(client: &BankClient, owner: &Keypair, to: &Pubkey, token: Token, tokens: u64) {
let instruction =
ExchangeInstruction::new_transfer_request(&owner.pubkey(), to, &id(), token, tokens);
exchange_instruction::transfer_request(&owner.pubkey(), to, &id(), token, tokens);
client
.process_instruction(owner, instruction)
.expect(&format!("{}:{}", line!(), file!()));
@ -582,7 +583,7 @@ mod test {
let dst = create_token_account(&client, &owner);
transfer(&client, &owner, &src, from_token, src_tokens);
let instruction = ExchangeInstruction::new_trade_request(
let instruction = exchange_instruction::trade_request(
&owner.pubkey(),
&trade,
direction,
@ -633,7 +634,7 @@ mod test {
let (client, owner) = create_client(&bank, mint_keypair);
let new = create_token_account(&client, &owner);
let instruction = ExchangeInstruction::new_account_request(&owner.pubkey(), &new);
let instruction = exchange_instruction::account_request(&owner.pubkey(), &new);
client
.process_instruction(&owner, instruction)
.expect_err(&format!("{}:{}", line!(), file!()));
@ -648,7 +649,7 @@ mod test {
let new = create_token_account(&client, &owner);
let instruction =
ExchangeInstruction::new_transfer_request(&owner.pubkey(), &new, &id(), Token::A, 42);
exchange_instruction::transfer_request(&owner.pubkey(), &new, &id(), Token::A, 42);
client
.process_instruction(&owner, instruction)
.expect(&format!("{}:{}", line!(), file!()));
@ -743,7 +744,7 @@ mod test {
3000,
);
let instruction = ExchangeInstruction::new_swap_request(
let instruction = exchange_instruction::swap_request(
&owner.pubkey(),
&swap,
&to_trade,

205
programs/exchange_api/src/exchange_transaction.rs
View File

@ -1,120 +1,103 @@
use crate::exchange_instruction::*;
use crate::exchange_instruction;
use crate::exchange_state::*;
use crate::id;
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use solana_sdk::transaction::Transaction;
use std::mem;
pub struct ExchangeTransaction {}
impl ExchangeTransaction {
pub fn new_account_request(
owner: &Keypair,
new: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = SystemInstruction::new_account(owner_id, new, 1, space, &id());
let request_ix = ExchangeInstruction::new_account_request(owner_id, new);
Transaction::new_signed_instructions(
&[owner],
vec![create_ix, request_ix],
recent_blockhash,
)
}
pub fn new_transfer_request(
owner: &Keypair,
to: &Pubkey,
from: &Pubkey,
token: Token,
tokens: u64,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let request_ix =
ExchangeInstruction::new_transfer_request(owner_id, to, from, token, tokens);
Transaction::new_signed_instructions(&[owner], vec![request_ix], recent_blockhash)
}
#[allow(clippy::too_many_arguments)]
pub fn new_trade_request(
owner: &Keypair,
trade: &Pubkey,
direction: Direction,
pair: TokenPair,
tokens: u64,
price: u64,
src_account: &Pubkey,
dst_account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = SystemInstruction::new_account(owner_id, trade, 1, space, &id());
let request_ix = ExchangeInstruction::new_trade_request(
owner_id,
trade,
direction,
pair,
tokens,
price,
src_account,
dst_account,
);
Transaction::new_signed_instructions(
&[owner],
vec![create_ix, request_ix],
recent_blockhash,
)
}
pub fn new_trade_cancellation(
owner: &Keypair,
trade: &Pubkey,
account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let request_ix = ExchangeInstruction::new_trade_cancellation(owner_id, trade, account);
Transaction::new_signed_instructions(&[owner], vec![request_ix], recent_blockhash)
}
pub fn new_swap_request(
owner: &Keypair,
swap: &Pubkey,
to_trade: &Pubkey,
from_trade: &Pubkey,
to_trade_account: &Pubkey,
from_trade_account: &Pubkey,
profit_account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = SystemInstruction::new_account(owner_id, swap, 1, space, &id());
let request_ix = ExchangeInstruction::new_swap_request(
owner_id,
swap,
to_trade,
from_trade,
to_trade_account,
from_trade_account,
profit_account,
);
Transaction::new_signed_instructions(
&[owner],
vec![create_ix, request_ix],
recent_blockhash,
)
}
pub fn account_request(
owner: &Keypair,
new: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = system_instruction::create_account(owner_id, new, 1, space, &id());
let request_ix = exchange_instruction::account_request(owner_id, new);
Transaction::new_signed_instructions(&[owner], vec![create_ix, request_ix], recent_blockhash)
}
pub fn transfer_request(
owner: &Keypair,
to: &Pubkey,
from: &Pubkey,
token: Token,
tokens: u64,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let request_ix = exchange_instruction::transfer_request(owner_id, to, from, token, tokens);
Transaction::new_signed_instructions(&[owner], vec![request_ix], recent_blockhash)
}
#[allow(clippy::too_many_arguments)]
pub fn trade_request(
owner: &Keypair,
trade: &Pubkey,
direction: Direction,
pair: TokenPair,
tokens: u64,
price: u64,
src_account: &Pubkey,
dst_account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = system_instruction::create_account(owner_id, trade, 1, space, &id());
let request_ix = exchange_instruction::trade_request(
owner_id,
trade,
direction,
pair,
tokens,
price,
src_account,
dst_account,
);
Transaction::new_signed_instructions(&[owner], vec![create_ix, request_ix], recent_blockhash)
}
pub fn trade_cancellation(
owner: &Keypair,
trade: &Pubkey,
account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let request_ix = exchange_instruction::trade_cancellation(owner_id, trade, account);
Transaction::new_signed_instructions(&[owner], vec![request_ix], recent_blockhash)
}
pub fn swap_request(
owner: &Keypair,
swap: &Pubkey,
to_trade: &Pubkey,
from_trade: &Pubkey,
to_trade_account: &Pubkey,
from_trade_account: &Pubkey,
profit_account: &Pubkey,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let owner_id = &owner.pubkey();
let space = mem::size_of::<ExchangeState>() as u64;
let create_ix = system_instruction::create_account(owner_id, swap, 1, space, &id());
let request_ix = exchange_instruction::swap_request(
owner_id,
swap,
to_trade,
from_trade,
to_trade_account,
from_trade_account,
profit_account,
);
Transaction::new_signed_instructions(&[owner], vec![create_ix, request_ix], recent_blockhash)
}

68
programs/stake_api/src/stake_instruction.rs
View File

@ -6,7 +6,7 @@ use serde_derive::{Deserialize, Serialize};
use solana_sdk::account::KeyedAccount;
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum StakeInstruction {
@ -22,44 +22,38 @@ pub enum StakeInstruction {
RedeemVoteCredits,
}
impl StakeInstruction {
pub fn new_account(from_id: &Pubkey, staker_id: &Pubkey, lamports: u64) -> Vec<Instruction> {
vec![SystemInstruction::new_account(
from_id,
staker_id,
lamports,
std::mem::size_of::<StakeState>() as u64,
&id(),
)]
}
pub fn create_account(from_id: &Pubkey, staker_id: &Pubkey, lamports: u64) -> Vec<Instruction> {
vec![system_instruction::create_account(
from_id,
staker_id,
lamports,
std::mem::size_of::<StakeState>() as u64,
&id(),
)]
}
pub fn new_redeem_vote_credits(
from_id: &Pubkey,
mining_pool_id: &Pubkey,
stake_id: &Pubkey,
vote_id: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*mining_pool_id, false),
AccountMeta::new(*stake_id, false),
AccountMeta::new(*vote_id, false),
];
Instruction::new(id(), &StakeInstruction::RedeemVoteCredits, account_metas)
}
pub fn redeem_vote_credits(
from_id: &Pubkey,
mining_pool_id: &Pubkey,
stake_id: &Pubkey,
vote_id: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*mining_pool_id, false),
AccountMeta::new(*stake_id, false),
AccountMeta::new(*vote_id, false),
];
Instruction::new(id(), &StakeInstruction::RedeemVoteCredits, account_metas)
}
pub fn new_delegate_stake(
from_id: &Pubkey,
stake_id: &Pubkey,
vote_id: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*stake_id, true),
AccountMeta::new(*vote_id, false),
];
Instruction::new(id(), &StakeInstruction::DelegateStake, account_metas)
}
pub fn delegate_stake(from_id: &Pubkey, stake_id: &Pubkey, vote_id: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*stake_id, true),
AccountMeta::new(*vote_id, false),
];
Instruction::new(id(), &StakeInstruction::DelegateStake, account_metas)
}
pub fn process_instruction(

92
programs/storage_api/src/storage_instruction.rs
View File

@ -26,51 +26,49 @@ pub enum StorageInstruction {
},
}
impl StorageInstruction {
pub fn new_mining_proof(
from_pubkey: &Pubkey,
sha_state: Hash,
entry_height: u64,
signature: Signature,
) -> Instruction {
let storage_instruction = StorageInstruction::SubmitMiningProof {
sha_state,
entry_height,
signature,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn new_advertise_recent_blockhash(
from_pubkey: &Pubkey,
storage_hash: Hash,
entry_height: u64,
) -> Instruction {
let storage_instruction = StorageInstruction::AdvertiseStorageRecentBlockhash {
hash: storage_hash,
entry_height,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn new_proof_validation(
from_pubkey: &Pubkey,
entry_height: u64,
proof_mask: Vec<ProofStatus>,
) -> Instruction {
let storage_instruction = StorageInstruction::ProofValidation {
entry_height,
proof_mask,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn new_reward_claim(from_pubkey: &Pubkey, entry_height: u64) -> Instruction {
let storage_instruction = StorageInstruction::ClaimStorageReward { entry_height };
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn mining_proof(
from_pubkey: &Pubkey,
sha_state: Hash,
entry_height: u64,
signature: Signature,
) -> Instruction {
let storage_instruction = StorageInstruction::SubmitMiningProof {
sha_state,
entry_height,
signature,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn advertise_recent_blockhash(
from_pubkey: &Pubkey,
storage_hash: Hash,
entry_height: u64,
) -> Instruction {
let storage_instruction = StorageInstruction::AdvertiseStorageRecentBlockhash {
hash: storage_hash,
entry_height,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn proof_validation(
from_pubkey: &Pubkey,
entry_height: u64,
proof_mask: Vec<ProofStatus>,
) -> Instruction {
let storage_instruction = StorageInstruction::ProofValidation {
entry_height,
proof_mask,
};
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}
pub fn reward_claim(from_pubkey: &Pubkey, entry_height: u64) -> Instruction {
let storage_instruction = StorageInstruction::ClaimStorageReward { entry_height };
let account_metas = vec![AccountMeta::new(*from_pubkey, true)];
Instruction::new(id(), &storage_instruction, account_metas)
}

36
programs/storage_api/src/storage_processor.rs
View File

@ -171,6 +171,7 @@ mod tests {
use super::*;
use crate::id;
use crate::storage_contract::ProofStatus;
use crate::storage_instruction;
use crate::ENTRIES_PER_SEGMENT;
use bincode::deserialize;
use solana_runtime::bank::Bank;
@ -181,7 +182,7 @@ mod tests {
use solana_sdk::instruction::Instruction;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
fn test_instruction(
ix: &Instruction,
@ -216,7 +217,7 @@ mod tests {
let mut user_account = Account::default();
keyed_accounts.push(KeyedAccount::new(&pubkey, true, &mut user_account));
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&pubkey,
Hash::default(),
ENTRIES_PER_SEGMENT,
@ -234,7 +235,7 @@ mod tests {
let mut accounts = [Account::default()];
let ix =
StorageInstruction::new_mining_proof(&pubkey, Hash::default(), 0, Signature::default());
storage_instruction::mining_proof(&pubkey, Hash::default(), 0, Signature::default());
assert!(test_instruction(&ix, &mut accounts).is_err());
let mut accounts = [Account::default(), Account::default(), Account::default()];
@ -250,7 +251,7 @@ mod tests {
accounts[1].data.resize(16 * 1024, 0);
let ix =
StorageInstruction::new_mining_proof(&pubkey, Hash::default(), 0, Signature::default());
storage_instruction::mining_proof(&pubkey, Hash::default(), 0, Signature::default());
// Haven't seen a transaction to roll over the epoch, so this should fail
assert!(test_instruction(&ix, &mut accounts).is_err());
@ -263,7 +264,7 @@ mod tests {
let mut accounts = [Account::default(), Account::default()];
accounts[0].data.resize(16 * 1024, 0);
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&pubkey,
Hash::default(),
ENTRIES_PER_SEGMENT,
@ -272,7 +273,7 @@ mod tests {
test_instruction(&ix, &mut accounts).unwrap();
let ix =
StorageInstruction::new_mining_proof(&pubkey, Hash::default(), 0, Signature::default());
storage_instruction::mining_proof(&pubkey, Hash::default(), 0, Signature::default());
test_instruction(&ix, &mut accounts).unwrap();
}
@ -286,7 +287,7 @@ mod tests {
let entry_height = 0;
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&pubkey,
Hash::default(),
ENTRIES_PER_SEGMENT,
@ -294,7 +295,7 @@ mod tests {
test_instruction(&ix, &mut accounts).unwrap();
let ix = StorageInstruction::new_mining_proof(
let ix = storage_instruction::mining_proof(
&pubkey,
Hash::default(),
entry_height,
@ -302,28 +303,25 @@ mod tests {
);
test_instruction(&ix, &mut accounts).unwrap();
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&pubkey,
Hash::default(),
ENTRIES_PER_SEGMENT * 2,
);
test_instruction(&ix, &mut accounts).unwrap();
let ix = StorageInstruction::new_proof_validation(
&pubkey,
entry_height,
vec![ProofStatus::Valid],
);
let ix =
storage_instruction::proof_validation(&pubkey, entry_height, vec![ProofStatus::Valid]);
test_instruction(&ix, &mut accounts).unwrap();
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&pubkey,
Hash::default(),
ENTRIES_PER_SEGMENT * 3,
);
test_instruction(&ix, &mut accounts).unwrap();
let ix = StorageInstruction::new_reward_claim(&pubkey, entry_height);
let ix = storage_instruction::reward_claim(&pubkey, entry_height);
test_instruction(&ix, &mut accounts).unwrap();
assert!(accounts[0].lamports == TOTAL_VALIDATOR_REWARDS);
@ -386,11 +384,11 @@ mod tests {
.transfer(10, &alice_keypair, &jack_pubkey)
.unwrap();
let ix = SystemInstruction::new_account(&alice_pubkey, &bob_pubkey, 1, 4 * 1024, &id());
let ix = system_instruction::create_account(&alice_pubkey, &bob_pubkey, 1, 4 * 1024, &id());
bank_client.process_instruction(&alice_keypair, ix).unwrap();
let ix = StorageInstruction::new_advertise_recent_blockhash(
let ix = storage_instruction::advertise_recent_blockhash(
&bob_pubkey,
storage_blockhash,
ENTRIES_PER_SEGMENT,
@ -399,7 +397,7 @@ mod tests {
bank_client.process_instruction(&bob_keypair, ix).unwrap();
let entry_height = 0;
let ix = StorageInstruction::new_mining_proof(
let ix = storage_instruction::mining_proof(
&bob_pubkey,
Hash::default(),
entry_height,

80
programs/vote_api/src/vote_instruction.rs
View File

@ -3,7 +3,7 @@ use crate::vote_state::VoteState;
use serde_derive::{Deserialize, Serialize};
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
#[derive(Serialize, Default, Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct Vote {
@ -37,44 +37,42 @@ pub enum VoteInstruction {
ClearCredits,
}
impl VoteInstruction {
fn new_initialize_account(vote_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, false)];
Instruction::new(id(), &VoteInstruction::InitializeAccount, account_metas)
}
pub fn new_account(from_id: &Pubkey, staker_id: &Pubkey, lamports: u64) -> Vec<Instruction> {
let space = VoteState::max_size() as u64;
let create_ix = SystemInstruction::new_account(&from_id, staker_id, lamports, space, &id());
let init_ix = VoteInstruction::new_initialize_account(staker_id);
vec![create_ix, init_ix]
}
pub fn new_clear_credits(vote_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(id(), &VoteInstruction::ClearCredits, account_metas)
}
pub fn new_delegate_stake(vote_id: &Pubkey, delegate_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(
id(),
&VoteInstruction::DelegateStake(*delegate_id),
account_metas,
)
}
pub fn new_authorize_voter(vote_id: &Pubkey, authorized_voter_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(
id(),
&VoteInstruction::AuthorizeVoter(*authorized_voter_id),
account_metas,
)
}
pub fn new_vote(vote_id: &Pubkey, vote: Vote) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(id(), &VoteInstruction::Vote(vote), account_metas)
}
fn initialize_account(vote_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, false)];
Instruction::new(id(), &VoteInstruction::InitializeAccount, account_metas)
}
pub fn create_account(from_id: &Pubkey, staker_id: &Pubkey, lamports: u64) -> Vec<Instruction> {
let space = VoteState::max_size() as u64;
let create_ix = system_instruction::create_account(&from_id, staker_id, lamports, space, &id());
let init_ix = initialize_account(staker_id);
vec![create_ix, init_ix]
}
pub fn clear_credits(vote_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(id(), &VoteInstruction::ClearCredits, account_metas)
}
pub fn delegate_stake(vote_id: &Pubkey, delegate_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(
id(),
&VoteInstruction::DelegateStake(*delegate_id),
account_metas,
)
}
pub fn authorize_voter(vote_id: &Pubkey, authorized_voter_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(
id(),
&VoteInstruction::AuthorizeVoter(*authorized_voter_id),
account_metas,
)
}
pub fn vote(vote_id: &Pubkey, vote: Vote) -> Instruction {
let account_metas = vec![AccountMeta::new(*vote_id, true)];
Instruction::new(id(), &VoteInstruction::Vote(vote), account_metas)
}

16
programs/vote_api/src/vote_processor.rs
View File

@ -45,7 +45,7 @@ pub fn process_instruction(
mod tests {
use super::*;
use crate::id;
use crate::vote_instruction::{Vote, VoteInstruction};
use crate::vote_instruction::{self, Vote};
use crate::vote_state::VoteState;
use solana_runtime::bank::{Bank, Result};
use solana_runtime::bank_client::BankClient;
@ -54,7 +54,7 @@ mod tests {
use solana_sdk::message::Message;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use solana_sdk::transaction::TransactionError;
fn create_bank(lamports: u64) -> (Bank, Keypair) {
@ -70,7 +70,7 @@ mod tests {
vote_id: &Pubkey,
lamports: u64,
) -> Result<()> {
let ixs = VoteInstruction::new_account(&from_keypair.pubkey(), vote_id, lamports);
let ixs = vote_instruction::create_account(&from_keypair.pubkey(), vote_id, lamports);
let message = Message::new(ixs);
bank_client.process_message(&[from_keypair], message)
}
@ -83,8 +83,8 @@ mod tests {
lamports: u64,
) -> Result<()> {
let vote_id = vote_keypair.pubkey();
let mut ixs = VoteInstruction::new_account(&from_keypair.pubkey(), &vote_id, lamports);
let delegate_ix = VoteInstruction::new_delegate_stake(&vote_id, delegate_id);
let mut ixs = vote_instruction::create_account(&from_keypair.pubkey(), &vote_id, lamports);
let delegate_ix = vote_instruction::delegate_stake(&vote_id, delegate_id);
ixs.push(delegate_ix);
let message = Message::new(ixs);
bank_client.process_message(&[&from_keypair, vote_keypair], message)
@ -95,7 +95,7 @@ mod tests {
vote_keypair: &Keypair,
tick_height: u64,
) -> Result<()> {
let vote_ix = VoteInstruction::new_vote(&vote_keypair.pubkey(), Vote::new(tick_height));
let vote_ix = vote_instruction::vote(&vote_keypair.pubkey(), Vote::new(tick_height));
bank_client.process_instruction(&vote_keypair, vote_ix)
}
@ -142,13 +142,13 @@ mod tests {
create_vote_account(&bank_client, &mallory_keypair, &vote_id, 100).unwrap();
let mallory_id = mallory_keypair.pubkey();
let mut vote_ix = VoteInstruction::new_vote(&vote_id, Vote::new(0));
let mut vote_ix = vote_instruction::vote(&vote_id, Vote::new(0));
vote_ix.accounts[0].is_signer = false; // <--- attack!! No signer required.
// Sneak in an instruction so that the transaction is signed but
// the 0th account in the second instruction is not! The program
// needs to check that it's signed.
let move_ix = SystemInstruction::new_transfer(&mallory_id, &vote_id, 1);
let move_ix = system_instruction::transfer(&mallory_id, &vote_id, 1);
let message = Message::new(vec![move_ix, vote_ix]);
let result = bank_client.process_message(&[&mallory_keypair], message);

6
runtime/benches/bank.rs
View File

@ -6,7 +6,7 @@ use solana_runtime::bank::*;
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::{DEFAULT_TICKS_PER_SLOT, MAX_RECENT_BLOCKHASHES};
use test::Bencher;
@ -21,7 +21,7 @@ fn bench_process_transaction(bencher: &mut Bencher) {
.map(|_| {
// Seed the 'from' account.
let rando0 = Keypair::new();
let tx = SystemTransaction::new_transfer(
let tx = system_transaction::transfer(
&mint_keypair,
&rando0.pubkey(),
10_000,
@ -32,7 +32,7 @@ fn bench_process_transaction(bencher: &mut Bencher) {
// Seed the 'to' account and a cell for its signature.
let rando1 = Keypair::new();
let tx = SystemTransaction::new_transfer(
let tx = system_transaction::transfer(
&rando0,
&rando1.pubkey(),
1,

108
runtime/src/bank.rs
View File

@ -20,7 +20,7 @@ use solana_sdk::hash::{extend_and_hash, Hash};
use solana_sdk::native_loader;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::timing::{duration_as_ms, duration_as_us, MAX_RECENT_BLOCKHASHES};
use solana_sdk::transaction::{Transaction, TransactionError};
use solana_vote_api::vote_instruction::Vote;
@ -777,7 +777,7 @@ impl Bank {
/// `n` lamports where `blockhash` is the last Entry ID observed by the client.
pub fn transfer(&self, n: u64, keypair: &Keypair, to: &Pubkey) -> Result<Signature> {
let blockhash = self.last_blockhash();
let tx = SystemTransaction::new_user_account(keypair, to, n, blockhash, 0);
let tx = system_transaction::create_user_account(keypair, to, n, blockhash, 0);
let signature = tx.signatures[0];
self.process_transaction(&tx).map(|_| signature)
}
@ -973,8 +973,8 @@ mod tests {
use solana_sdk::hash;
use solana_sdk::instruction::InstructionError;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_instruction;
use solana_sdk::system_transaction;
#[test]
fn test_bank_new() {
@ -1027,8 +1027,8 @@ mod tests {
let bank = Bank::new(&genesis_block);
assert_eq!(bank.last_blockhash(), genesis_block.hash());
let t1 = SystemTransaction::new_transfer(&mint_keypair, &key1, 1, genesis_block.hash(), 0);
let t2 = SystemTransaction::new_transfer(&mint_keypair, &key2, 1, genesis_block.hash(), 0);
let t1 = system_transaction::transfer(&mint_keypair, &key1, 1, genesis_block.hash(), 0);
let t2 = system_transaction::transfer(&mint_keypair, &key2, 1, genesis_block.hash(), 0);
let res = bank.process_transactions(&vec![t1.clone(), t2.clone()]);
assert_eq!(res.len(), 2);
assert_eq!(res[0], Ok(()));
@ -1051,7 +1051,7 @@ mod tests {
let key2 = Pubkey::new_rand();
let bank = Bank::new(&genesis_block);
let instructions =
SystemInstruction::new_transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]);
system_instruction::transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]);
let tx = Transaction::new_signed_instructions(
&[&mint_keypair],
instructions,
@ -1076,7 +1076,7 @@ mod tests {
let key2 = Pubkey::new_rand();
let bank = Bank::new(&genesis_block);
let instructions =
SystemInstruction::new_transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]);
system_instruction::transfer_many(&mint_keypair.pubkey(), &[(key1, 1), (key2, 1)]);
let tx = Transaction::new_signed_instructions(
&[&mint_keypair],
instructions,
@ -1098,7 +1098,7 @@ mod tests {
let dest = Keypair::new();
// source with 0 program context
let tx = SystemTransaction::new_user_account(
let tx = system_transaction::create_user_account(
&mint_keypair,
&dest.pubkey(),
2,
@ -1217,13 +1217,8 @@ mod tests {
let key1 = Keypair::new();
let key2 = Keypair::new();
let tx = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
2,
genesis_block.hash(),
0,
);
let tx =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 2, genesis_block.hash(), 0);
let initial_balance = bank.get_balance(&leader);
assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&leader), initial_balance + 3);
@ -1231,7 +1226,7 @@ mod tests {
assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 100 - 5 - 3);
bank.fee_calculator.lamports_per_signature = 1;
let tx = SystemTransaction::new_transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
let tx = system_transaction::transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(bank.get_balance(&leader), initial_balance + 4);
assert_eq!(bank.get_balance(&key1.pubkey()), 0);
@ -1246,20 +1241,10 @@ mod tests {
let mut bank = Bank::new(&genesis_block);
let key = Keypair::new();
let tx1 = SystemTransaction::new_transfer(
&mint_keypair,
&key.pubkey(),
2,
genesis_block.hash(),
0,
);
let tx2 = SystemTransaction::new_transfer(
&mint_keypair,
&key.pubkey(),
5,
genesis_block.hash(),
0,
);
let tx1 =
system_transaction::transfer(&mint_keypair, &key.pubkey(), 2, genesis_block.hash(), 0);
let tx2 =
system_transaction::transfer(&mint_keypair, &key.pubkey(), 5, genesis_block.hash(), 0);
let results = vec![
Ok(()),
@ -1282,14 +1267,14 @@ mod tests {
let (genesis_block, mint_keypair) = GenesisBlock::new(2);
let bank = Bank::new(&genesis_block);
let keypair = Keypair::new();
let tx0 = SystemTransaction::new_user_account(
let tx0 = system_transaction::create_user_account(
&mint_keypair,
&keypair.pubkey(),
2,
genesis_block.hash(),
0,
);
let tx1 = SystemTransaction::new_user_account(
let tx1 = system_transaction::create_user_account(
&keypair,
&mint_keypair.pubkey(),
1,
@ -1322,7 +1307,7 @@ mod tests {
let alice = Keypair::new();
let bob = Keypair::new();
let tx1 = SystemTransaction::new_user_account(
let tx1 = system_transaction::create_user_account(
&mint_keypair,
&alice.pubkey(),
1,
@ -1362,7 +1347,7 @@ mod tests {
let keypair = Keypair::new();
let bank = Bank::new(&genesis_block);
let tx = SystemTransaction::new_transfer(
let tx = system_transaction::transfer(
&mint_keypair,
&keypair.pubkey(),
1,
@ -1393,7 +1378,7 @@ mod tests {
bank.transfer(1, &mint_keypair, &key1.pubkey()).unwrap();
assert_eq!(bank.get_balance(&key1.pubkey()), 1);
let tx = SystemTransaction::new_transfer(&key1, &key1.pubkey(), 1, genesis_block.hash(), 0);
let tx = system_transaction::transfer(&key1, &key1.pubkey(), 1, genesis_block.hash(), 0);
let res = bank.process_transactions(&vec![tx.clone()]);
assert_eq!(res.len(), 1);
assert_eq!(bank.get_balance(&key1.pubkey()), 1);
@ -1427,13 +1412,8 @@ mod tests {
let key1 = Keypair::new();
let parent = Arc::new(Bank::new(&genesis_block));
let tx = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
1,
genesis_block.hash(),
0,
);
let tx =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(parent.process_transaction(&tx), Ok(()));
let bank = new_from_parent(&parent);
assert_eq!(
@ -1450,16 +1430,11 @@ mod tests {
let key2 = Keypair::new();
let parent = Arc::new(Bank::new(&genesis_block));
let tx = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
1,
genesis_block.hash(),
0,
);
let tx =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(parent.process_transaction(&tx), Ok(()));
let bank = new_from_parent(&parent);
let tx = SystemTransaction::new_transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
let tx = system_transaction::transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
assert_eq!(parent.get_signature_status(&tx.signatures[0]), None);
}
@ -1516,13 +1491,8 @@ mod tests {
let key2 = Keypair::new();
let parent = Arc::new(Bank::new(&genesis_block));
let tx_move_mint_to_1 = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
1,
genesis_block.hash(),
0,
);
let tx_move_mint_to_1 =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_block.hash(), 0);
trace!("parent process tx ");
assert_eq!(parent.process_transaction(&tx_move_mint_to_1), Ok(()));
trace!("done parent process tx ");
@ -1542,7 +1512,7 @@ mod tests {
assert_eq!(bank.transaction_count(), parent.transaction_count());
let tx_move_1_to_2 =
SystemTransaction::new_transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
system_transaction::transfer(&key1, &key2.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(bank.process_transaction(&tx_move_1_to_2), Ok(()));
assert_eq!(bank.transaction_count(), 2);
assert_eq!(parent.transaction_count(), 1);
@ -1660,7 +1630,7 @@ mod tests {
let key = Keypair::new();
let mut move_instruction =
SystemInstruction::new_transfer(&mint_keypair.pubkey(), &key.pubkey(), 0);
system_instruction::transfer(&mint_keypair.pubkey(), &key.pubkey(), 0);
move_instruction.accounts[0].is_signer = false;
let tx = Transaction::new_signed_instructions(
@ -1741,13 +1711,8 @@ mod tests {
let (genesis_block, mint_keypair) = GenesisBlock::new(500);
let bank = Arc::new(Bank::new(&genesis_block));
let key1 = Keypair::new();
let tx_move_mint_to_1 = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
1,
genesis_block.hash(),
0,
);
let tx_move_mint_to_1 =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(bank.process_transaction(&tx_move_mint_to_1), Ok(()));
assert_eq!(bank.is_delta.load(Ordering::Relaxed), true);
}
@ -1760,13 +1725,8 @@ mod tests {
assert_eq!(bank.is_votable(), false);
// Set is_delta to true
let tx_move_mint_to_1 = SystemTransaction::new_transfer(
&mint_keypair,
&key1.pubkey(),
1,
genesis_block.hash(),
0,
);
let tx_move_mint_to_1 =
system_transaction::transfer(&mint_keypair, &key1.pubkey(), 1, genesis_block.hash(), 0);
assert_eq!(bank.process_transaction(&tx_move_mint_to_1), Ok(()));
assert_eq!(bank.is_votable(), false);

6
runtime/src/bank_client.rs
View File

@ -3,7 +3,7 @@ use solana_sdk::instruction::Instruction;
use solana_sdk::message::Message;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
use solana_sdk::transaction::{Transaction, TransactionError};
pub struct BankClient<'a> {
@ -42,7 +42,7 @@ impl<'a> BankClient<'a> {
keypair: &Keypair,
pubkey: &Pubkey,
) -> Result<(), TransactionError> {
let move_instruction = SystemInstruction::new_transfer(&keypair.pubkey(), pubkey, lamports);
let move_instruction = system_instruction::transfer(&keypair.pubkey(), pubkey, lamports);
self.process_instruction(keypair, move_instruction)
}
}
@ -65,7 +65,7 @@ mod tests {
// Create 2-2 Multisig Transfer instruction.
let bob_pubkey = Pubkey::new_rand();
let mut move_instruction = SystemInstruction::new_transfer(&john_pubkey, &bob_pubkey, 42);
let mut move_instruction = system_instruction::transfer(&john_pubkey, &bob_pubkey, 42);
move_instruction
.accounts
.push(AccountMeta::new(jane_pubkey, true));

10
runtime/src/loader_utils.rs
View File

@ -1,10 +1,10 @@
use crate::bank_client::BankClient;
use serde::Serialize;
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::loader_instruction::LoaderInstruction;
use solana_sdk::loader_instruction;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_instruction;
pub fn load_program(
bank_client: &BankClient,
@ -15,7 +15,7 @@ pub fn load_program(
let program_keypair = Keypair::new();
let program_pubkey = program_keypair.pubkey();
let instruction = SystemInstruction::new_account(
let instruction = system_instruction::create_account(
&from_keypair.pubkey(),
&program_pubkey,
1,
@ -30,14 +30,14 @@ pub fn load_program(
let mut offset = 0;
for chunk in program.chunks(chunk_size) {
let instruction =
LoaderInstruction::new_write(&program_pubkey, loader_id, offset, chunk.to_vec());
loader_instruction::write(&program_pubkey, loader_id, offset, chunk.to_vec());
bank_client
.process_instruction(&program_keypair, instruction)
.unwrap();
offset += chunk_size as u32;
}
let instruction = LoaderInstruction::new_finalize(&program_pubkey, loader_id);
let instruction = loader_instruction::finalize(&program_pubkey, loader_id);
bank_client
.process_instruction(&program_keypair, instruction)
.unwrap();

1
runtime/src/system_instruction_processor.rs
View File

@ -110,7 +110,6 @@ mod tests {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_program;
use solana_sdk::transaction::TransactionError;

8
sdk/src/fee_calculator.rs
View File

@ -21,7 +21,7 @@ impl FeeCalculator {
mod tests {
use super::*;
use crate::pubkey::Pubkey;
use crate::system_instruction::SystemInstruction;
use crate::system_instruction;
#[test]
fn test_fee_calculator_calculate_fee() {
@ -35,13 +35,13 @@ mod tests {
// One signature, a fee.
let pubkey0 = Pubkey::new(&[0; 32]);
let pubkey1 = Pubkey::new(&[1; 32]);
let ix0 = SystemInstruction::new_transfer(&pubkey0, &pubkey1, 1);
let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
let message = Message::new(vec![ix0]);
assert_eq!(FeeCalculator::new(2).calculate_fee(&message), 2);
// Two signatures, double the fee.
let ix0 = SystemInstruction::new_transfer(&pubkey0, &pubkey1, 1);
let ix1 = SystemInstruction::new_transfer(&pubkey1, &pubkey0, 1);
let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
let message = Message::new(vec![ix0, ix1]);
assert_eq!(FeeCalculator::new(2).calculate_fee(&message), 4);
}

31
sdk/src/loader_instruction.rs
View File

@ -20,23 +20,16 @@ pub enum LoaderInstruction {
Finalize,
}
impl LoaderInstruction {
pub fn new_write(
account_id: &Pubkey,
program_id: &Pubkey,
offset: u32,
bytes: Vec<u8>,
) -> Instruction {
let account_metas = vec![AccountMeta::new(*account_id, true)];
Instruction::new(
*program_id,
&LoaderInstruction::Write { offset, bytes },
account_metas,
)
}
pub fn new_finalize(account_id: &Pubkey, program_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*account_id, true)];
Instruction::new(*program_id, &LoaderInstruction::Finalize, account_metas)
}
pub fn write(account_id: &Pubkey, program_id: &Pubkey, offset: u32, bytes: Vec<u8>) -> Instruction {
let account_metas = vec![AccountMeta::new(*account_id, true)];
Instruction::new(
*program_id,
&LoaderInstruction::Write { offset, bytes },
account_metas,
)
}
pub fn finalize(account_id: &Pubkey, program_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*account_id, true)];
Instruction::new(*program_id, &LoaderInstruction::Finalize, account_metas)
}

110
sdk/src/system_instruction.rs
View File

@ -31,65 +31,63 @@ pub enum SystemInstruction {
Transfer { lamports: u64 },
}
impl SystemInstruction {
pub fn new_account(
from_id: &Pubkey,
to_id: &Pubkey,
lamports: u64,
space: u64,
program_id: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*to_id, false),
];
Instruction::new(
system_program::id(),
&SystemInstruction::CreateAccount {
lamports,
space,
program_id: *program_id,
},
account_metas,
)
}
pub fn create_account(
from_id: &Pubkey,
to_id: &Pubkey,
lamports: u64,
space: u64,
program_id: &Pubkey,
) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*to_id, false),
];
Instruction::new(
system_program::id(),
&SystemInstruction::CreateAccount {
lamports,
space,
program_id: *program_id,
},
account_metas,
)
}
/// Create and sign a transaction to create a system account
pub fn new_user_account(from_id: &Pubkey, to_id: &Pubkey, lamports: u64) -> Instruction {
let program_id = system_program::id();
Self::new_account(from_id, to_id, lamports, 0, &program_id)
}
/// Create and sign a transaction to create a system account
pub fn create_user_account(from_id: &Pubkey, to_id: &Pubkey, lamports: u64) -> Instruction {
let program_id = system_program::id();
create_account(from_id, to_id, lamports, 0, &program_id)
}
pub fn new_assign(from_id: &Pubkey, program_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*from_id, true)];
Instruction::new(
system_program::id(),
&SystemInstruction::Assign {
program_id: *program_id,
},
account_metas,
)
}
pub fn assign(from_id: &Pubkey, program_id: &Pubkey) -> Instruction {
let account_metas = vec![AccountMeta::new(*from_id, true)];
Instruction::new(
system_program::id(),
&SystemInstruction::Assign {
program_id: *program_id,
},
account_metas,
)
}
pub fn new_transfer(from_id: &Pubkey, to_id: &Pubkey, lamports: u64) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*to_id, false),
];
Instruction::new(
system_program::id(),
&SystemInstruction::Transfer { lamports },
account_metas,
)
}
pub fn transfer(from_id: &Pubkey, to_id: &Pubkey, lamports: u64) -> Instruction {
let account_metas = vec![
AccountMeta::new(*from_id, true),
AccountMeta::new(*to_id, false),
];
Instruction::new(
system_program::id(),
&SystemInstruction::Transfer { lamports },
account_metas,
)
}
/// Create and sign new SystemInstruction::Transfer transaction to many destinations
pub fn new_transfer_many(from_id: &Pubkey, to_lamports: &[(Pubkey, u64)]) -> Vec<Instruction> {
to_lamports
.iter()
.map(|(to_id, lamports)| SystemInstruction::new_transfer(from_id, to_id, *lamports))
.collect()
}
/// Create and sign new SystemInstruction::Transfer transaction to many destinations
pub fn transfer_many(from_id: &Pubkey, to_lamports: &[(Pubkey, u64)]) -> Vec<Instruction> {
to_lamports
.iter()
.map(|(to_id, lamports)| transfer(from_id, to_id, *lamports))
.collect()
}
#[cfg(test)]
@ -107,7 +105,7 @@ mod tests {
let carol_pubkey = Pubkey::new_rand();
let to_lamports = vec![(bob_pubkey, 1), (carol_pubkey, 2)];
let instructions = SystemInstruction::new_transfer_many(&alice_pubkey, &to_lamports);
let instructions = transfer_many(&alice_pubkey, &to_lamports);
assert_eq!(instructions.len(), 2);
assert_eq!(get_keys(&instructions[0]), vec![alice_pubkey, bob_pubkey]);
assert_eq!(get_keys(&instructions[1]), vec![alice_pubkey, carol_pubkey]);

130
sdk/src/system_transaction.rs
View File

@ -3,74 +3,70 @@
use crate::hash::Hash;
use crate::pubkey::Pubkey;
use crate::signature::{Keypair, KeypairUtil};
use crate::system_instruction::SystemInstruction;
use crate::system_instruction;
use crate::system_program;
use crate::transaction::Transaction;
pub struct SystemTransaction {}
impl SystemTransaction {
/// Create and sign new SystemInstruction::CreateAccount transaction
pub fn new_account(
from_keypair: &Keypair,
to: &Pubkey,
recent_blockhash: Hash,
lamports: u64,
space: u64,
program_id: &Pubkey,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let create_instruction =
SystemInstruction::new_account(&from_pubkey, to, lamports, space, program_id);
let instructions = vec![create_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}
/// Create and sign a transaction to create a system account
pub fn new_user_account(
from_keypair: &Keypair,
to: &Pubkey,
lamports: u64,
recent_blockhash: Hash,
fee: u64,
) -> Transaction {
let program_id = system_program::id();
Self::new_account(
from_keypair,
to,
recent_blockhash,
lamports,
0,
&program_id,
fee,
)
}
/// Create and sign new SystemInstruction::Assign transaction
pub fn new_assign(
from_keypair: &Keypair,
recent_blockhash: Hash,
program_id: &Pubkey,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let assign_instruction = SystemInstruction::new_assign(&from_pubkey, program_id);
let instructions = vec![assign_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}
/// Create and sign new SystemInstruction::Transfer transaction
pub fn new_transfer(
from_keypair: &Keypair,
to: &Pubkey,
lamports: u64,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let move_instruction = SystemInstruction::new_transfer(&from_pubkey, to, lamports);
let instructions = vec![move_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}
/// Create and sign new SystemInstruction::CreateAccount transaction
pub fn create_account(
from_keypair: &Keypair,
to: &Pubkey,
recent_blockhash: Hash,
lamports: u64,
space: u64,
program_id: &Pubkey,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let create_instruction =
system_instruction::create_account(&from_pubkey, to, lamports, space, program_id);
let instructions = vec![create_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}
/// Create and sign a transaction to create a system account
pub fn create_user_account(
from_keypair: &Keypair,
to: &Pubkey,
lamports: u64,
recent_blockhash: Hash,
fee: u64,
) -> Transaction {
let program_id = system_program::id();
create_account(
from_keypair,
to,
recent_blockhash,
lamports,
0,
&program_id,
fee,
)
}
/// Create and sign new system_instruction::Assign transaction
pub fn assign(
from_keypair: &Keypair,
recent_blockhash: Hash,
program_id: &Pubkey,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let assign_instruction = system_instruction::assign(&from_pubkey, program_id);
let instructions = vec![assign_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}
/// Create and sign new system_instruction::Transfer transaction
pub fn transfer(
from_keypair: &Keypair,
to: &Pubkey,
lamports: u64,
recent_blockhash: Hash,
_fee: u64,
) -> Transaction {
let from_pubkey = from_keypair.pubkey();
let move_instruction = system_instruction::transfer(&from_pubkey, to, lamports);
let instructions = vec![move_instruction];
Transaction::new_signed_instructions(&[from_keypair], instructions, recent_blockhash)
}

4
sdk/src/transaction.rs
View File

@ -200,7 +200,7 @@ mod tests {
use super::*;
use crate::instruction::AccountMeta;
use crate::signature::Keypair;
use crate::system_instruction::SystemInstruction;
use crate::system_instruction;
use bincode::{deserialize, serialize, serialized_size};
use std::mem::size_of;
@ -321,7 +321,7 @@ mod tests {
let alice_keypair = Keypair::new();
let alice_pubkey = alice_keypair.pubkey();
let bob_pubkey = Pubkey::new_rand();
let ix = SystemInstruction::new_transfer(&alice_pubkey, &bob_pubkey, 42);
let ix = system_instruction::transfer(&alice_pubkey, &bob_pubkey, 42);
let expected_data_size = size_of::<u32>() + size_of::<u64>();
assert_eq!(expected_data_size, 12);

12
tests/thin_client.rs
View File

@ -10,7 +10,7 @@ use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_state::VoteState;
use std::fs::remove_dir_all;
@ -32,7 +32,7 @@ pub fn transfer(
to,
blockhash
);
let transaction = SystemTransaction::new_user_account(keypair, to, lamports, *blockhash, 0);
let transaction = system_transaction::create_user_account(keypair, to, lamports, *blockhash, 0);
thin_client.transfer_signed(&transaction)
}
@ -76,15 +76,15 @@ fn test_bad_sig() {
let blockhash = client.get_recent_blockhash().unwrap();
let tx = SystemTransaction::new_user_account(&alice, &bob_pubkey, 500, blockhash, 0);
let tx = system_transaction::create_user_account(&alice, &bob_pubkey, 500, blockhash, 0);
let _sig = client.transfer_signed(&tx).unwrap();
let blockhash = client.get_recent_blockhash().unwrap();
let mut tr2 = SystemTransaction::new_user_account(&alice, &bob_pubkey, 501, blockhash, 0);
let mut tr2 = system_transaction::create_user_account(&alice, &bob_pubkey, 501, blockhash, 0);
let mut instruction2 = deserialize(tr2.data(0)).unwrap();
if let SystemInstruction::Transfer { ref mut lamports } = instruction2 {
if let system_instruction::Transfer { ref mut lamports } = instruction2 {
*lamports = 502;
}
tr2.instructions[0].data = serialize(&instruction2).unwrap();
@ -125,7 +125,7 @@ fn test_register_vote_account() {
let blockhash = client.get_recent_blockhash().unwrap();
let instructions =
VoteInstruction::new_account(&validator_keypair.pubkey(), &vote_account_id, 1);
vote_instruction::create_account(&validator_keypair.pubkey(), &vote_account_id, 1);
let transaction =
Transaction::new_signed_instructions(&[&validator_keypair], instructions, blockhash);
let signature = client.transfer_signed(&transaction).unwrap();

33
wallet/src/wallet.rs
View File

@ -5,7 +5,7 @@ use log::*;
use serde_json;
use serde_json::json;
use solana_budget_api;
use solana_budget_api::budget_instruction::BudgetInstruction;
use solana_budget_api::budget_instruction;
use solana_client::rpc_client::{get_rpc_request_str, RpcClient};
#[cfg(not(test))]
use solana_drone::drone::request_airdrop_transaction;
@ -14,13 +14,13 @@ use solana_drone::drone::DRONE_PORT;
use solana_drone::drone_mock::request_airdrop_transaction;
use solana_sdk::bpf_loader;
use solana_sdk::hash::Hash;
use solana_sdk::loader_instruction::LoaderInstruction;
use solana_sdk::loader_instruction;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::rpc_port::DEFAULT_RPC_PORT;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_instruction;
use std::fs::File;
use std::io::Read;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@ -333,13 +333,13 @@ fn process_configure_staking(
let recent_blockhash = rpc_client.get_recent_blockhash()?;
let mut ixs = vec![];
if let Some(delegate_id) = delegate_option {
ixs.push(VoteInstruction::new_delegate_stake(
ixs.push(vote_instruction::delegate_stake(
&config.keypair.pubkey(),
&delegate_id,
));
}
if let Some(authorized_voter_id) = authorized_voter_option {
ixs.push(VoteInstruction::new_authorize_voter(
ixs.push(vote_instruction::authorize_voter(
&config.keypair.pubkey(),
&authorized_voter_id,
));
@ -356,7 +356,8 @@ fn process_create_staking(
lamports: u64,
) -> ProcessResult {
let recent_blockhash = rpc_client.get_recent_blockhash()?;
let ixs = VoteInstruction::new_account(&config.keypair.pubkey(), voting_account_id, lamports);
let ixs =
vote_instruction::create_account(&config.keypair.pubkey(), voting_account_id, lamports);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], ixs, recent_blockhash);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.keypair)?;
Ok(signature_str.to_string())
@ -390,7 +391,7 @@ fn process_deploy(
)
})?;
let mut tx = SystemTransaction::new_account(
let mut tx = system_transaction::create_account(
&config.keypair,
&program_id.pubkey(),
blockhash,
@ -411,7 +412,7 @@ fn process_deploy(
.chunks(USERDATA_CHUNK_SIZE)
.zip(0..)
.map(|(chunk, i)| {
let instruction = LoaderInstruction::new_write(
let instruction = loader_instruction::write(
&program_id.pubkey(),
&bpf_loader::id(),
(i * USERDATA_CHUNK_SIZE) as u32,
@ -423,7 +424,7 @@ fn process_deploy(
rpc_client.send_and_confirm_transactions(write_transactions, &program_id)?;
trace!("Finalizing program account");
let instruction = LoaderInstruction::new_finalize(&program_id.pubkey(), &bpf_loader::id());
let instruction = loader_instruction::finalize(&program_id.pubkey(), &bpf_loader::id());
let mut tx = Transaction::new_signed_instructions(&[&program_id], vec![instruction], blockhash);
rpc_client
.send_and_confirm_transaction(&mut tx, &program_id)
@ -450,7 +451,7 @@ fn process_pay(
let blockhash = rpc_client.get_recent_blockhash()?;
if timestamp == None && *witnesses == None {
let mut tx = SystemTransaction::new_transfer(&config.keypair, to, lamports, blockhash, 0);
let mut tx = system_transaction::transfer(&config.keypair, to, lamports, blockhash, 0);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.keypair)?;
Ok(signature_str.to_string())
} else if *witnesses == None {
@ -463,7 +464,7 @@ fn process_pay(
let contract_state = Keypair::new();
// Initializing contract
let ixs = BudgetInstruction::new_on_date(
let ixs = budget_instruction::on_date(
&config.keypair.pubkey(),
to,
&contract_state.pubkey(),
@ -494,7 +495,7 @@ fn process_pay(
let contract_state = Keypair::new();
// Initializing contract
let ixs = BudgetInstruction::new_when_signed(
let ixs = budget_instruction::when_signed(
&config.keypair.pubkey(),
to,
&contract_state.pubkey(),
@ -517,7 +518,7 @@ fn process_pay(
fn process_cancel(rpc_client: &RpcClient, config: &WalletConfig, pubkey: &Pubkey) -> ProcessResult {
let blockhash = rpc_client.get_recent_blockhash()?;
let ix = BudgetInstruction::new_apply_signature(
let ix = budget_instruction::apply_signature(
&config.keypair.pubkey(),
pubkey,
&config.keypair.pubkey(),
@ -548,7 +549,7 @@ fn process_time_elapsed(
let blockhash = rpc_client.get_recent_blockhash()?;
let ix = BudgetInstruction::new_apply_timestamp(&config.keypair.pubkey(), pubkey, to, dt);
let ix = budget_instruction::apply_timestamp(&config.keypair.pubkey(), pubkey, to, dt);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], vec![ix], blockhash);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.keypair)?;
@ -569,7 +570,7 @@ fn process_witness(
}
let blockhash = rpc_client.get_recent_blockhash()?;
let ix = BudgetInstruction::new_apply_signature(&config.keypair.pubkey(), pubkey, to);
let ix = budget_instruction::apply_signature(&config.keypair.pubkey(), pubkey, to);
let mut tx = Transaction::new_signed_instructions(&[&config.keypair], vec![ix], blockhash);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.keypair)?;